feat(ai): add client injection to streamAnthropic

[gklein]

streamAnthropic hardcodes client creation via internal createClient().
This makes it impossible for extensions to reuse the streaming logic with
Anthropic-compatible clients that need their own auth and URL handling
but share the same Messages API.

Without this, an extension must reimplement streamAnthropic's event loop,
buildParams, convertMessages, convertTools, mapStopReason, cache
control, and abort handling (~400 lines). PR #1157 took that approach and
was correctly rejected — the duplication was the problem, not the idea.

Proposed change: add one optional field to AnthropicOptions:

client?: Anthropic;

And one conditional in streamAnthropic:

const { client, isOAuthToken } = options?.client
    ? { client: options.client, isOAuthToken: false }
    : createClient(model, apiKey, ...);

When client is provided, createClient() is skipped and isOAuthToken
is forced to false (disabling Claude Code identity headers and tool name
remapping — correct for non-OAuth credentials). Everything else runs unchanged.

When not provided: zero behavior change.

This keeps core minimal — no new dependencies, no new provider code.
For example, an extension for Google Vertex AI could use Anthropic's
@anthropic-ai/vertex-sdk, which extends the base Anthropic class
with the same messages.stream() API but uses Google ADC auth and
rewrites URLs to the Vertex endpoint. The extension would create
the client, inject it via this option, and get full streaming reuse.
The heavy dependencies (@anthropic-ai/vertex-sdk, google-auth-library)
would stay in the extension's package.json, not in core.

Example: how an extension would use this

import AnthropicVertex from "@anthropic-ai/vertex-sdk";
import {
    type AnthropicOptions,
    type Model,
    createAssistantMessageEventStream,
    streamAnthropic,
} from "@mariozechner/pi-ai";

// AnthropicVertex extends Anthropic — same messages.stream() API,
// but handles Google ADC auth and Vertex URL rewriting internally.
const vertexClient = new AnthropicVertex({
    projectId: process.env.GOOGLE_CLOUD_PROJECT,
    region: process.env.GOOGLE_CLOUD_LOCATION,
});

function streamVertexAnthropic(model, context, options) {
    const stream = createAssistantMessageEventStream();

    (async () => {
        try {
            // Inject the Vertex client — streamAnthropic reuses 100% of its
            // streaming, message conversion, params building, and error handling.
            const opts: AnthropicOptions = {
                ...base,
                client: vertexClient,
            };
            const innerStream = streamAnthropic(model, context, opts);
            for await (const event of innerStream) stream.push(event);
            stream.end();
        } catch (error) {
            // ... error handling ...
        }
    })();

    return stream;
}

// Register as extension — heavy deps stay in extension package.json
export default function (pi) {
    pi.registerProvider("anthropic-vertex", {
        models: VERTEX_MODELS,
        streamSimple: streamVertexAnthropic,
    });
}

Without the client option, streamVertexAnthropic would need to
reimplement everything streamAnthropic does internally (~400 lines).
With it, the extension is ~30 lines of glue code.