@zhivex-ai/gemini 0.6.0 → 0.7.0-next.0

package/dist/index.js

@@ -8,10 +8,17 @@ const capabilities = {
     toolChoice: true,
     parallelToolCalls: false,
     vision: true,
-    files: false,
+    files: true,
     audioInput: false,
     audioOutput: false,
     embeddings: true,
+    fileSearch: true,
+    urlContext: true,
+    contextCaching: true,
+    batch: true,
+    interactions: true,
+    rawPrediction: true,
+    computerUse: true,
     reasoning: true,
     webSearch: true,
     agentCapabilities: {
@@ -19,9 +26,9 @@ const capabilities = {
         toolChoiceNone: true,
         approvalRequests: false,
         hostedWebSearch: true,
-        hostedFileSearch: false,
+        hostedFileSearch: true,
         remoteMcp: false,
-        computerUse: false,
+        computerUse: true,
         codeExecution: true,
         toolsets: false
     }
@@ -60,6 +67,85 @@ const groundedCapabilities = {
     ...capabilities,
     webSearch: true
 };
+const imageGenerationCapabilities = {
+    ...capabilities,
+    streaming: false,
+    tools: false,
+    structuredOutput: false,
+    jsonMode: false,
+    toolChoice: false,
+    parallelToolCalls: false,
+    embeddings: false,
+    imageGeneration: true,
+    videoGeneration: false,
+    musicGeneration: false,
+    reasoning: false,
+    webSearch: false,
+    agentCapabilities: {
+        supportTier: "tier-c",
+        toolChoiceNone: false,
+        approvalRequests: false,
+        hostedWebSearch: false,
+        hostedFileSearch: false,
+        remoteMcp: false,
+        computerUse: false,
+        codeExecution: false,
+        toolsets: false
+    }
+};
+const videoGenerationCapabilities = {
+    ...capabilities,
+    streaming: false,
+    tools: false,
+    structuredOutput: false,
+    jsonMode: false,
+    toolChoice: false,
+    parallelToolCalls: false,
+    vision: false,
+    embeddings: false,
+    imageGeneration: false,
+    videoGeneration: true,
+    musicGeneration: false,
+    reasoning: false,
+    webSearch: false,
+    agentCapabilities: {
+        supportTier: "tier-c",
+        toolChoiceNone: false,
+        approvalRequests: false,
+        hostedWebSearch: false,
+        hostedFileSearch: false,
+        remoteMcp: false,
+        computerUse: false,
+        codeExecution: false,
+        toolsets: false
+    }
+};
+const musicGenerationCapabilities = {
+    ...capabilities,
+    streaming: false,
+    tools: false,
+    structuredOutput: false,
+    jsonMode: false,
+    toolChoice: false,
+    parallelToolCalls: false,
+    embeddings: false,
+    imageGeneration: false,
+    videoGeneration: false,
+    musicGeneration: true,
+    reasoning: false,
+    webSearch: false,
+    agentCapabilities: {
+        supportTier: "tier-c",
+        toolChoiceNone: false,
+        approvalRequests: false,
+        hostedWebSearch: false,
+        hostedFileSearch: false,
+        remoteMcp: false,
+        computerUse: false,
+        codeExecution: false,
+        toolsets: false
+    }
+};
 const realtimeCapabilities = {
     ...capabilities,
     streaming: false,
@@ -90,6 +176,207 @@ const toBase64 = (data) => {
     const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
     return Buffer.from(bytes).toString("base64");
 };
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (ms <= 0) {
+        resolve();
+        return;
+    }
+    if (signal?.aborted) {
+        reject(new Error("Operation aborted."));
+        return;
+    }
+    const timeout = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+    }, ms);
+    const onAbort = () => {
+        clearTimeout(timeout);
+        reject(new Error("Operation aborted."));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+});
+const splitGenerationConfig = (providerOptions) => {
+    const { generationConfig, ...rest } = providerOptions ?? {};
+    return {
+        generationConfig: generationConfig && typeof generationConfig === "object" ? generationConfig : {},
+        providerOptions: rest
+    };
+};
+const mediaInputToPart = (media) => media.uri
+    ? {
+        fileData: {
+            mimeType: media.mediaType,
+            fileUri: media.uri
+        }
+    }
+    : {
+        inlineData: {
+            mimeType: media.mediaType,
+            data: media.data ? toBase64(media.data) : ""
+        }
+    };
+const collectInlineMedia = (json, fallbackMediaType) => {
+    const text = [];
+    const media = [];
+    const candidates = Array.isArray(json.candidates) ? json.candidates : [];
+    for (const candidate of candidates) {
+        const parts = Array.isArray(candidate?.content?.parts) ? candidate.content.parts : [];
+        for (const part of parts) {
+            if (typeof part.text === "string" && part.text) {
+                text.push(part.text);
+            }
+            const inlineData = part.inlineData ?? part.inline_data;
+            if (inlineData?.data) {
+                media.push({
+                    data: Uint8Array.from(Buffer.from(inlineData.data, "base64")),
+                    mediaType: inlineData.mimeType ?? inlineData.mime_type ?? fallbackMediaType,
+                    text: typeof part.text === "string" ? part.text : undefined
+                });
+            }
+        }
+    }
+    return {
+        media,
+        text: text.length ? text.join("\n") : undefined
+    };
+};
+const mediaInputToVeoImage = (media) => media.uri
+    ? {
+        gcsUri: media.uri,
+        mimeType: media.mediaType
+    }
+    : {
+        bytesBase64Encoded: media.data ? toBase64(media.data) : "",
+        mimeType: media.mediaType
+    };
+const collectVideos = (json) => {
+    const samples = json.response?.generateVideoResponse?.generatedSamples ??
+        json.response?.generatedVideos ??
+        json.response?.generated_videos ??
+        [];
+    return (Array.isArray(samples) ? samples : [])
+        .map((sample) => sample.video ?? sample)
+        .map((video) => ({
+        data: video.videoBytes
+            ? Uint8Array.from(Buffer.from(video.videoBytes, "base64"))
+            : video.bytesBase64Encoded
+                ? Uint8Array.from(Buffer.from(video.bytesBase64Encoded, "base64"))
+                : undefined,
+        uri: video.uri ?? video.gcsUri,
+        mediaType: video.mimeType ?? "video/mp4",
+        providerMetadata: video
+    }))
+        .filter((video) => video.data || video.uri);
+};
+const dataToBytes = async (data) => {
+    if (typeof data === "string") {
+        return new TextEncoder().encode(data);
+    }
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    if (data instanceof ArrayBuffer) {
+        return new Uint8Array(data);
+    }
+    return new Uint8Array(await data.arrayBuffer());
+};
+const bytesToArrayBuffer = (bytes) => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+const normalizeUploadedFile = (json) => {
+    const file = json.file ?? json;
+    return {
+        name: file.name ?? "",
+        uri: file.uri ?? file.fileUri ?? file.file_uri,
+        mimeType: file.mimeType ?? file.mime_type,
+        sizeBytes: file.sizeBytes ?? file.size_bytes,
+        state: file.state,
+        displayName: file.displayName ?? file.display_name,
+        rawResponse: json,
+        providerMetadata: file
+    };
+};
+const normalizeFileSearchStore = (json) => ({
+    name: json.name ?? "",
+    displayName: json.displayName ?? json.display_name,
+    createTime: json.createTime ?? json.create_time,
+    updateTime: json.updateTime ?? json.update_time,
+    rawResponse: json,
+    providerMetadata: json
+});
+const normalizeCachedContent = (json) => ({
+    name: json.name ?? "",
+    model: json.model,
+    displayName: json.displayName ?? json.display_name,
+    createTime: json.createTime ?? json.create_time,
+    updateTime: json.updateTime ?? json.update_time,
+    expireTime: json.expireTime ?? json.expire_time,
+    usageMetadata: json.usageMetadata ?? json.usage_metadata,
+    rawResponse: json,
+    providerMetadata: json
+});
+const normalizeBatchJob = (json) => ({
+    name: json.name ?? "",
+    model: json.model,
+    state: json.state ?? json.metadata?.state,
+    done: json.done,
+    createTime: json.createTime ?? json.create_time ?? json.metadata?.createTime,
+    updateTime: json.updateTime ?? json.update_time ?? json.metadata?.updateTime,
+    rawResponse: json,
+    providerMetadata: json
+});
+const normalizeInteraction = (json) => ({
+    id: json.id ?? json.name ?? "",
+    name: json.name,
+    model: json.model,
+    status: json.status,
+    outputs: json.outputs,
+    rawResponse: json,
+    providerMetadata: json
+});
+const normalizeOperation = (json) => ({
+    name: json.name ?? "",
+    done: json.done,
+    response: json.response,
+    error: json.error,
+    metadata: json.metadata,
+    rawResponse: json
+});
+const normalizePredictionResult = (json) => ({
+    predictions: json.predictions,
+    operationName: json.name,
+    operation: json.name || json.done !== undefined ? normalizeOperation(json) : undefined,
+    rawResponse: json,
+    providerMetadata: json
+});
+const appendQuery = (url, query) => {
+    const parsed = new URL(url);
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined) {
+            parsed.searchParams.set(key, String(value));
+        }
+    }
+    return parsed.toString();
+};
+const geminiUploadBaseURL = (baseURL) => baseURL.replace(/\/v1beta\/?$/, "/upload/v1beta");
+const pollGeminiOperation = async (operation, baseURL, apiKey, fetcher, options) => {
+    if (options.pollIntervalMs === undefined && options.timeoutMs === undefined) {
+        return operation;
+    }
+    const startedAt = Date.now();
+    const timeoutMs = options.timeoutMs ?? 600_000;
+    let current = operation;
+    while (!current.done) {
+        if (Date.now() - startedAt >= timeoutMs) {
+            throw new Error(`Gemini operation "${operation.name}" timed out after ${timeoutMs}ms.`);
+        }
+        await sleep(options.pollIntervalMs ?? 5_000, options.abortSignal);
+        const response = await withRetry(() => fetcher(`${baseURL}/${current.name}?key=${apiKey}`, {
+            method: "GET",
+            signal: options.abortSignal
+        }), options);
+        current = normalizeOperation(await parseJson(response));
+    }
+    return current;
+};
 const systemInstruction = (messages) => {
     const text = messages
         .filter((message) => message.role === "system")
@@ -110,6 +397,13 @@ const mapPart = (part) => {
                     data: part.image
                 }
             };
+        case "file":
+            return {
+                fileData: {
+                    mimeType: part.mediaType,
+                    fileUri: part.data
+                }
+            };
         case "tool-call":
             return {
                 functionCall: {
@@ -484,6 +778,9 @@ const parseAssistantMessage = (candidate) => ({
                 }
             };
         }
+        if (part.inlineData?.data && String(part.inlineData.mimeType ?? "").startsWith("image/")) {
+            return { type: "image", image: part.inlineData.data, mediaType: part.inlineData.mimeType };
+        }
         return { type: "text", text: JSON.stringify(part) };
     }) ?? []
 });
@@ -495,162 +792,746 @@ const extractGroundingSources = (candidate) => (candidate?.groundingMetadata?.gr
     providerMetadata: chunk
 }))
     .filter((source) => typeof source.url === "string");
-class GeminiLanguageModel {
-    modelId;
+class GeminiFilesClient {
     apiKey;
     baseURL;
     fetcher;
-    provider = "gemini";
-    capabilities = capabilities;
-    constructor(modelId, apiKey, baseURL, fetcher) {
-        this.modelId = modelId;
+    constructor(apiKey, baseURL, fetcher) {
         this.apiKey = apiKey;
         this.baseURL = baseURL;
         this.fetcher = fetcher;
     }
-    url(action) {
-        const separator = action.includes("?") ? "&" : "?";
-        return `${this.baseURL}/models/${this.modelId}:${action}${separator}key=${this.apiKey}`;
+    url(path, query = {}) {
+        return appendQuery(`${this.baseURL}/${path}`, { key: this.apiKey, ...query });
     }
-    async generate(input) {
+    uploadUrl(path) {
+        return appendQuery(`${geminiUploadBaseURL(this.baseURL)}/${path}`, { key: this.apiKey });
+    }
+    async upload(input) {
+        const bytes = await dataToBytes(input.data);
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(this.url("generateContent"), {
+            const startResponse = await withRetry(() => this.fetcher(this.uploadUrl("files"), {
                 method: "POST",
-                headers: { "content-type": "application/json" },
+                headers: {
+                    "content-type": "application/json",
+                    "x-goog-upload-protocol": "resumable",
+                    "x-goog-upload-command": "start",
+                    "x-goog-upload-header-content-length": String(bytes.byteLength),
+                    "x-goog-upload-header-content-type": input.mediaType
+                },
                 signal,
                 body: JSON.stringify({
-                    contents: mapMessages(input.messages),
-                    systemInstruction: systemInstruction(input.messages),
-                    tools: mapTools(input.tools),
-                    ...input.providerOptions,
-                    toolConfig: mapToolConfig(input.toolChoice, input.tools),
-                    generationConfig: generationConfig(this.modelId, input)
+                    file: {
+                        ...(input.displayName ? { displayName: input.displayName } : {}),
+                        ...(input.name ? { name: input.name } : {}),
+                        ...(input.providerOptions ?? {})
+                    }
                 })
             }), input);
-            const json = await parseJson(response);
-            const candidate = json.candidates?.[0];
-            const assistantMessage = parseAssistantMessage(candidate);
-            return {
-                messages: [assistantMessage],
-                text: assistantMessage.parts
-                    .filter((part) => part.type === "text")
-                    .map((part) => part.text)
-                    .join(""),
-                finishReason: normalizeFinishReason(candidate?.finishReason),
-                providerFinishReason: candidate?.finishReason,
-                rawResponse: json
-            };
+            if (!startResponse.ok) {
+                await parseJson(startResponse);
+            }
+            const resumableUrl = startResponse.headers.get("x-goog-upload-url");
+            if (!resumableUrl) {
+                throw new ProviderHTTPError('Gemini file upload did not return "x-goog-upload-url".', 500);
+            }
+            const uploadResponse = await withRetry(() => this.fetcher(resumableUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": input.mediaType,
+                    "x-goog-upload-command": "upload, finalize",
+                    "x-goog-upload-offset": "0"
+                },
+                signal,
+                body: new Blob([bytesToArrayBuffer(bytes)], { type: input.mediaType })
+            }), input);
+            return normalizeUploadedFile(await parseJson(uploadResponse));
         }
         finally {
             cleanup();
         }
     }
-    async stream(input) {
+    async get(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
-        const response = await withRetry(() => this.fetcher(this.url("streamGenerateContent?alt=sse"), {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            signal,
-            body: JSON.stringify({
-                contents: mapMessages(input.messages),
-                systemInstruction: systemInstruction(input.messages),
-                tools: mapTools(input.tools),
-                ...input.providerOptions,
-                toolConfig: mapToolConfig(input.toolChoice, input.tools),
-                generationConfig: generationConfig(this.modelId, input)
-            })
-        }), input);
-        return (async function* () {
-            try {
-                for await (const event of streamSSE(response)) {
-                    const json = JSON.parse(event.data);
-                    const candidate = json.candidates?.[0];
-                    const parts = candidate?.content?.parts ?? [];
-                    for (const [index, part] of parts.entries()) {
-                        if (part.text) {
-                            yield { type: "text-delta", textDelta: part.text };
-                        }
-                        if (part.functionCall) {
-                            yield {
-                                type: "tool-call",
-                                toolCall: {
-                                    id: part.functionCall.id ?? `${part.functionCall.name}-${index}`,
-                                    name: part.functionCall.name,
-                                    input: part.functionCall.args ?? {}
-                                }
-                            };
-                        }
-                    }
-                    if (candidate?.finishReason) {
-                        yield {
-                            type: "finish",
-                            finishReason: normalizeFinishReason(candidate.finishReason),
-                            providerFinishReason: candidate.finishReason
-                        };
-                    }
-                }
-            }
-            finally {
-                cleanup();
-            }
-        })();
-    }
-}
-class GeminiEmbeddingModel {
-    modelId;
-    apiKey;
-    baseURL;
-    fetcher;
-    provider = "gemini";
-    capabilities = capabilities;
-    constructor(modelId, apiKey, baseURL, fetcher) {
-        this.modelId = modelId;
-        this.apiKey = apiKey;
-        this.baseURL = baseURL;
-        this.fetcher = fetcher;
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(input.name), { method: "GET", signal }), input);
+            return normalizeUploadedFile(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
     }
-    async embed(input) {
+    async list(input = {}) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const embeddings = await Promise.all(input.values.map(async (value) => {
-                const response = await withRetry(() => this.fetcher(`${this.baseURL}/models/${this.modelId}:embedContent?key=${this.apiKey}`, {
-                    method: "POST",
-                    headers: { "content-type": "application/json" },
-                    signal,
-                    body: JSON.stringify({
-                        content: { parts: [{ text: value }] }
-                    })
-                }), input);
-                const json = await parseJson(response);
-                return json.embedding.values;
-            }));
+            const response = await withRetry(() => this.fetcher(this.url("files", { pageSize: input.pageSize, pageToken: input.pageToken }), { method: "GET", signal }), input);
+            const json = await parseJson(response);
             return {
-                embeddings
+                files: (json.files ?? []).map(normalizeUploadedFile),
+                nextPageToken: json.nextPageToken,
+                rawResponse: json
             };
         }
         finally {
             cleanup();
         }
     }
+    async delete(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(input.name), { method: "DELETE", signal }), input);
+            const json = await parseJson(response);
+            return { name: input.name, rawResponse: json };
+        }
+        finally {
+            cleanup();
+        }
+    }
 }
-class GeminiTranscriptionModel {
-    modelId;
+class GeminiFileSearchStoresClient {
     apiKey;
     baseURL;
     fetcher;
-    provider = "gemini";
-    capabilities = transcriptionCapabilities;
-    constructor(modelId, apiKey, baseURL, fetcher) {
-        this.modelId = modelId;
+    constructor(apiKey, baseURL, fetcher) {
         this.apiKey = apiKey;
         this.baseURL = baseURL;
         this.fetcher = fetcher;
     }
-    async transcribe(input) {
+    url(path, query = {}) {
+        return appendQuery(`${this.baseURL}/${path}`, { key: this.apiKey, ...query });
+    }
+    uploadUrl(path) {
+        return appendQuery(`${geminiUploadBaseURL(this.baseURL)}/${path}`, { key: this.apiKey });
+    }
+    async create(input = {}) {
         const { signal, cleanup } = withTimeoutSignal(input);
         try {
-            const response = await withRetry(() => this.fetcher(`${this.baseURL}/models/${this.modelId}:generateContent?key=${this.apiKey}`, {
+            const response = await withRetry(() => this.fetcher(this.url("fileSearchStores"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify({
+                    ...(input.displayName ? { displayName: input.displayName } : {}),
+                    ...(input.providerOptions ?? {})
+                })
+            }), input);
+            return normalizeFileSearchStore(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async upload(input) {
+        const bytes = await dataToBytes(input.data);
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const startResponse = await withRetry(() => this.fetcher(this.uploadUrl(`${input.storeName}:uploadToFileSearchStore`), {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    "x-goog-upload-protocol": "resumable",
+                    "x-goog-upload-command": "start",
+                    "x-goog-upload-header-content-length": String(bytes.byteLength),
+                    "x-goog-upload-header-content-type": input.mediaType
+                },
+                signal,
+                body: JSON.stringify({
+                    file: {
+                        ...(input.displayName ? { displayName: input.displayName } : {}),
+                        ...(input.filename ? { name: input.filename } : {})
+                    },
+                    ...(input.providerOptions ?? {})
+                })
+            }), input);
+            if (!startResponse.ok) {
+                await parseJson(startResponse);
+            }
+            const resumableUrl = startResponse.headers.get("x-goog-upload-url");
+            if (!resumableUrl) {
+                throw new ProviderHTTPError('Gemini file search upload did not return "x-goog-upload-url".', 500);
+            }
+            const uploadResponse = await withRetry(() => this.fetcher(resumableUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": input.mediaType,
+                    "x-goog-upload-command": "upload, finalize",
+                    "x-goog-upload-offset": "0"
+                },
+                signal,
+                body: new Blob([bytesToArrayBuffer(bytes)], { type: input.mediaType })
+            }), input);
+            return pollGeminiOperation(normalizeOperation(await parseJson(uploadResponse)), this.baseURL, this.apiKey, this.fetcher, {
+                ...input,
+                abortSignal: signal
+            });
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async importFile(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(`${input.storeName}:importFile`), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify({
+                    fileName: input.fileName,
+                    ...(input.providerOptions ?? {})
+                })
+            }), input);
+            return pollGeminiOperation(normalizeOperation(await parseJson(response)), this.baseURL, this.apiKey, this.fetcher, {
+                ...input,
+                abortSignal: signal
+            });
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async get(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(input.name), { method: "GET", signal }), input);
+            return normalizeFileSearchStore(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async list(input = {}) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("fileSearchStores", { pageSize: input.pageSize, pageToken: input.pageToken }), { method: "GET", signal }), input);
+            const json = await parseJson(response);
+            return {
+                stores: (json.fileSearchStores ?? json.file_search_stores ?? []).map(normalizeFileSearchStore),
+                nextPageToken: json.nextPageToken,
+                rawResponse: json
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async delete(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(input.name), { method: "DELETE", signal }), input);
+            const json = await parseJson(response);
+            return { name: input.name, rawResponse: json };
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+class GeminiContextCachesClient {
+    apiKey;
+    baseURL;
+    fetcher;
+    constructor(apiKey, baseURL, fetcher) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    url(path, query = {}) {
+        return appendQuery(`${this.baseURL}/${path}`, { key: this.apiKey, ...query });
+    }
+    async create(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("cachedContents"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify({
+                    model: input.modelId.startsWith("models/") ? input.modelId : `models/${input.modelId}`,
+                    contents: mapMessages(input.contents),
+                    ...(input.system ? { systemInstruction: { parts: [{ text: input.system }] } } : { systemInstruction: systemInstruction(input.contents) }),
+                    ...(input.tools ? { tools: mapTools(toToolSet(input.tools)) } : {}),
+                    ...(input.displayName ? { displayName: input.displayName } : {}),
+                    ...(input.ttl ? { ttl: input.ttl } : {}),
+                    ...(input.expireTime ? { expireTime: input.expireTime } : {}),
+                    ...(input.providerOptions ?? {})
+                })
+            }), input);
+            return normalizeCachedContent(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async get(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(input.name), { method: "GET", signal }), input);
+            return normalizeCachedContent(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async list(input = {}) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("cachedContents", { pageSize: input.pageSize, pageToken: input.pageToken }), { method: "GET", signal }), input);
+            const json = await parseJson(response);
+            return {
+                caches: (json.cachedContents ?? json.cached_contents ?? []).map(normalizeCachedContent),
+                nextPageToken: json.nextPageToken,
+                rawResponse: json
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async delete(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(input.name), { method: "DELETE", signal }), input);
+            const json = await parseJson(response);
+            return { name: input.name, rawResponse: json };
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+class GeminiBatchesClient {
+    apiKey;
+    baseURL;
+    fetcher;
+    constructor(apiKey, baseURL, fetcher) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    url(path, query = {}) {
+        return appendQuery(`${this.baseURL}/${path}`, { key: this.apiKey, ...query });
+    }
+    async create(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(`models/${input.modelId}:batchGenerateContent`), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify({
+                    batch: {
+                        ...(input.displayName ? { displayName: input.displayName } : {}),
+                        inputConfig: input.fileName
+                            ? { fileName: input.fileName }
+                            : {
+                                requests: {
+                                    requests: input.requests ?? []
+                                }
+                            },
+                        ...(input.providerOptions ?? {})
+                    }
+                })
+            }), input);
+            return normalizeBatchJob(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async get(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(input.name), { method: "GET", signal }), input);
+            return normalizeBatchJob(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async list(input = {}) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("batches", { pageSize: input.pageSize, pageToken: input.pageToken }), { method: "GET", signal }), input);
+            const json = await parseJson(response);
+            return {
+                batches: (json.batches ?? []).map(normalizeBatchJob),
+                nextPageToken: json.nextPageToken,
+                rawResponse: json
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async cancel(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(`${input.name}:cancel`), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify(input.providerOptions ?? {})
+            }), input);
+            return normalizeBatchJob(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async delete(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(`${input.name}:delete`), { method: "POST", signal }), input);
+            const json = await parseJson(response);
+            return { name: input.name, rawResponse: json };
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+class GeminiInteractionsClient {
+    apiKey;
+    baseURL;
+    fetcher;
+    constructor(apiKey, baseURL, fetcher) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    url(path, query = {}) {
+        return appendQuery(`${this.baseURL}/${path}`, { key: this.apiKey, ...query });
+    }
+    body(input, stream = false) {
+        return {
+            ...(input.modelId ? { model: input.modelId } : {}),
+            ...(input.agent ? { agent: input.agent } : {}),
+            input: input.input,
+            ...(input.previousInteractionId ? { previous_interaction_id: input.previousInteractionId } : {}),
+            ...(input.tools ? { tools: mapTools(toToolSet(input.tools)) } : {}),
+            ...(input.background !== undefined ? { background: input.background } : {}),
+            ...(input.store !== undefined ? { store: input.store } : {}),
+            ...(stream ? { stream: true } : {}),
+            ...(input.providerOptions ?? {})
+        };
+    }
+    async create(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("interactions"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify(this.body(input))
+            }), input);
+            return normalizeInteraction(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async get(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(`interactions/${input.id}`), { method: "GET", signal }), input);
+            return normalizeInteraction(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async stream(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        const response = await withRetry(() => this.fetcher(this.url("interactions", { alt: "sse" }), {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            signal,
+            body: JSON.stringify(this.body(input, true))
+        }), input);
+        return (async function* () {
+            try {
+                for await (const event of streamSSE(response)) {
+                    const json = JSON.parse(event.data);
+                    const text = json.text ??
+                        json.delta?.text ??
+                        json.output?.text ??
+                        (Array.isArray(json.outputs) ? json.outputs.find((output) => typeof output.text === "string")?.text : undefined);
+                    if (typeof text === "string" && text) {
+                        yield { type: "text-delta", textDelta: text };
+                    }
+                    else {
+                        yield { type: "provider-data", provider: "gemini", data: json };
+                    }
+                    if (json.status === "completed" || json.done) {
+                        yield { type: "finish", finishReason: "stop" };
+                    }
+                }
+            }
+            finally {
+                cleanup();
+            }
+        })();
+    }
+}
+class GeminiPredictionModel {
+    modelId;
+    apiKey;
+    baseURL;
+    fetcher;
+    provider = "gemini";
+    capabilities = {
+        ...capabilities,
+        rawPrediction: true
+    };
+    constructor(modelId, apiKey, baseURL, fetcher) {
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    url(action) {
+        return `${this.baseURL}/models/${this.modelId}:${action}?key=${this.apiKey}`;
+    }
+    body(input) {
+        return input.body ?? {
+            ...(input.instances ? { instances: input.instances } : {}),
+            ...(input.parameters ? { parameters: input.parameters } : {}),
+            ...(input.providerOptions ?? {})
+        };
+    }
+    async predictRaw(input) {
+        const action = typeof input.providerOptions?.action === "string" ? input.providerOptions.action : "predict";
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url(action), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify(this.body(input))
+            }), input);
+            return normalizePredictionResult(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async rawPredict(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("rawPredict"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify(this.body(input))
+            }), input);
+            return normalizePredictionResult(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async invoke(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("invoke"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify(this.body(input))
+            }), input);
+            return normalizePredictionResult(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async predictLongRunning(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("predictLongRunning"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify(this.body(input))
+            }), input);
+            return normalizeOperation(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async fetchPredictionOperation(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/${input.name}?key=${this.apiKey}`, {
+                method: "GET",
+                signal
+            }), input);
+            return normalizeOperation(await parseJson(response));
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+class GeminiLanguageModel {
+    modelId;
+    apiKey;
+    baseURL;
+    fetcher;
+    provider = "gemini";
+    capabilities = capabilities;
+    constructor(modelId, apiKey, baseURL, fetcher) {
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    url(action) {
+        const separator = action.includes("?") ? "&" : "?";
+        return `${this.baseURL}/models/${this.modelId}:${action}${separator}key=${this.apiKey}`;
+    }
+    async generate(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(this.url("generateContent"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify({
+                    contents: mapMessages(input.messages),
+                    systemInstruction: systemInstruction(input.messages),
+                    tools: mapTools(input.tools),
+                    ...input.providerOptions,
+                    toolConfig: mapToolConfig(input.toolChoice, input.tools),
+                    generationConfig: generationConfig(this.modelId, input)
+                })
+            }), input);
+            const json = await parseJson(response);
+            const candidate = json.candidates?.[0];
+            const assistantMessage = parseAssistantMessage(candidate);
+            return {
+                messages: [assistantMessage],
+                text: assistantMessage.parts
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join(""),
+                finishReason: normalizeFinishReason(candidate?.finishReason),
+                providerFinishReason: candidate?.finishReason,
+                rawResponse: json
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+    async stream(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        const response = await withRetry(() => this.fetcher(this.url("streamGenerateContent?alt=sse"), {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            signal,
+            body: JSON.stringify({
+                contents: mapMessages(input.messages),
+                systemInstruction: systemInstruction(input.messages),
+                tools: mapTools(input.tools),
+                ...input.providerOptions,
+                toolConfig: mapToolConfig(input.toolChoice, input.tools),
+                generationConfig: generationConfig(this.modelId, input)
+            })
+        }), input);
+        return (async function* () {
+            try {
+                for await (const event of streamSSE(response)) {
+                    const json = JSON.parse(event.data);
+                    const candidate = json.candidates?.[0];
+                    const parts = candidate?.content?.parts ?? [];
+                    for (const [index, part] of parts.entries()) {
+                        if (part.text) {
+                            yield { type: "text-delta", textDelta: part.text };
+                        }
+                        if (part.functionCall) {
+                            yield {
+                                type: "tool-call",
+                                toolCall: {
+                                    id: part.functionCall.id ?? `${part.functionCall.name}-${index}`,
+                                    name: part.functionCall.name,
+                                    input: part.functionCall.args ?? {}
+                                }
+                            };
+                        }
+                    }
+                    if (candidate?.finishReason) {
+                        yield {
+                            type: "finish",
+                            finishReason: normalizeFinishReason(candidate.finishReason),
+                            providerFinishReason: candidate.finishReason
+                        };
+                    }
+                }
+            }
+            finally {
+                cleanup();
+            }
+        })();
+    }
+}
+class GeminiEmbeddingModel {
+    modelId;
+    apiKey;
+    baseURL;
+    fetcher;
+    provider = "gemini";
+    capabilities = capabilities;
+    constructor(modelId, apiKey, baseURL, fetcher) {
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    async embed(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const embeddings = await Promise.all(input.values.map(async (value) => {
+                const response = await withRetry(() => this.fetcher(`${this.baseURL}/models/${this.modelId}:embedContent?key=${this.apiKey}`, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    signal,
+                    body: JSON.stringify({
+                        content: { parts: [{ text: value }] }
+                    })
+                }), input);
+                const json = await parseJson(response);
+                return json.embedding.values;
+            }));
+            return {
+                embeddings
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+class GeminiTranscriptionModel {
+    modelId;
+    apiKey;
+    baseURL;
+    fetcher;
+    provider = "gemini";
+    capabilities = transcriptionCapabilities;
+    constructor(modelId, apiKey, baseURL, fetcher) {
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    async transcribe(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        try {
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/models/${this.modelId}:generateContent?key=${this.apiKey}`, {
                 method: "POST",
                 headers: { "content-type": "application/json" },
                 signal,
@@ -736,6 +1617,183 @@ class GeminiSpeechModel {
         }
     }
 }
+class GeminiImageGenerationModel {
+    modelId;
+    apiKey;
+    baseURL;
+    fetcher;
+    provider = "gemini";
+    capabilities = imageGenerationCapabilities;
+    constructor(modelId, apiKey, baseURL, fetcher) {
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    async generateImage(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        const { generationConfig, providerOptions } = splitGenerationConfig(input.providerOptions);
+        try {
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/models/${this.modelId}:generateContent?key=${this.apiKey}`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify({
+                    contents: [
+                        {
+                            role: "user",
+                            parts: [
+                                { text: input.negativePrompt ? `${input.prompt}\n\nNegative prompt: ${input.negativePrompt}` : input.prompt },
+                                ...(input.images ?? []).map(mediaInputToPart)
+                            ]
+                        }
+                    ],
+                    ...providerOptions,
+                    generationConfig: {
+                        responseModalities: ["TEXT", "IMAGE"],
+                        ...(input.count ? { candidateCount: input.count } : {}),
+                        ...(input.outputMimeType ? { responseMimeType: input.outputMimeType } : {}),
+                        ...(input.aspectRatio || input.size
+                            ? {
+                                imageConfig: {
+                                    ...(input.aspectRatio ? { aspectRatio: input.aspectRatio } : {}),
+                                    ...(input.size ? { imageSize: input.size } : {})
+                                }
+                            }
+                            : {}),
+                        ...generationConfig
+                    }
+                })
+            }), input);
+            const json = await parseJson(response);
+            const { media, text } = collectInlineMedia(json, input.outputMimeType ?? "image/png");
+            return {
+                images: media,
+                text,
+                rawResponse: json
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+class GeminiMusicGenerationModel {
+    modelId;
+    apiKey;
+    baseURL;
+    fetcher;
+    provider = "gemini";
+    capabilities = musicGenerationCapabilities;
+    constructor(modelId, apiKey, baseURL, fetcher) {
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    async generateMusic(input) {
+        const { signal, cleanup } = withTimeoutSignal(input);
+        const { generationConfig, providerOptions } = splitGenerationConfig(input.providerOptions);
+        try {
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/models/${this.modelId}:generateContent?key=${this.apiKey}`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify({
+                    contents: [
+                        {
+                            role: "user",
+                            parts: [
+                                { text: input.negativePrompt ? `${input.prompt}\n\nNegative prompt: ${input.negativePrompt}` : input.prompt },
+                                ...(input.images ?? []).map(mediaInputToPart)
+                            ]
+                        }
+                    ],
+                    ...providerOptions,
+                    generationConfig: {
+                        responseModalities: ["AUDIO", "TEXT"],
+                        ...(input.outputMimeType ? { responseMimeType: input.outputMimeType } : {}),
+                        ...generationConfig
+                    }
+                })
+            }), input);
+            const json = await parseJson(response);
+            const { media, text } = collectInlineMedia(json, input.outputMimeType ?? "audio/mpeg");
+            return {
+                audio: media,
+                text,
+                rawResponse: json
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+class GeminiVideoGenerationModel {
+    modelId;
+    apiKey;
+    baseURL;
+    fetcher;
+    provider = "gemini";
+    capabilities = videoGenerationCapabilities;
+    constructor(modelId, apiKey, baseURL, fetcher) {
+        this.modelId = modelId;
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+        this.fetcher = fetcher;
+    }
+    async generateVideo(input) {
+        const timeoutMs = input.timeoutMs ?? 600_000;
+        const { signal, cleanup } = withTimeoutSignal({ ...input, timeoutMs });
+        const startedAt = Date.now();
+        try {
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/models/${this.modelId}:predictLongRunning?key=${this.apiKey}`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                signal,
+                body: JSON.stringify({
+                    instances: [
+                        {
+                            prompt: input.prompt,
+                            ...(input.image ? { image: mediaInputToVeoImage(input.image) } : {})
+                        }
+                    ],
+                    parameters: {
+                        ...(input.count ? { sampleCount: input.count } : {}),
+                        ...(input.aspectRatio ? { aspectRatio: input.aspectRatio } : {}),
+                        ...(input.negativePrompt ? { negativePrompt: input.negativePrompt } : {}),
+                        ...(input.durationSeconds ? { durationSeconds: input.durationSeconds } : {}),
+                        ...(input.outputStorageUri ? { storageUri: input.outputStorageUri } : {}),
+                        ...input.providerOptions
+                    }
+                })
+            }), input);
+            let operation = await parseJson(response);
+            const operationName = operation.name;
+            const pollIntervalMs = input.pollIntervalMs ?? 10_000;
+            while (!operation.done) {
+                if (Date.now() - startedAt >= timeoutMs) {
+                    throw new Error(`Gemini video generation timed out after ${timeoutMs}ms.`);
+                }
+                await sleep(pollIntervalMs, signal);
+                const pollResponse = await withRetry(() => this.fetcher(`${this.baseURL}/${operationName}?key=${this.apiKey}`, {
+                    method: "GET",
+                    signal
+                }), input);
+                operation = await parseJson(pollResponse);
+            }
+            return {
+                videos: collectVideos(operation),
+                operationName,
+                rawResponse: operation
+            };
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
 class GeminiGroundedLanguageModel {
     modelId;
     apiKey;
@@ -925,8 +1983,17 @@ export const createGemini = (options = {}) => {
         embeddingModel: (modelId) => new GeminiEmbeddingModel(modelId, apiKey, baseURL, fetcher),
         transcriptionModel: (modelId) => new GeminiTranscriptionModel(modelId, apiKey, baseURL, fetcher),
         speechModel: (modelId) => new GeminiSpeechModel(modelId, apiKey, baseURL, fetcher),
+        imageGenerationModel: (modelId) => new GeminiImageGenerationModel(modelId, apiKey, baseURL, fetcher),
+        videoGenerationModel: (modelId) => new GeminiVideoGenerationModel(modelId, apiKey, baseURL, fetcher),
+        musicGenerationModel: (modelId) => new GeminiMusicGenerationModel(modelId, apiKey, baseURL, fetcher),
         realtimeModel: (modelId) => new GeminiRealtimeModel(modelId, apiKey, baseURL, fetcher, options.realtimeConnectionFactory, options.realtimeURL, options.browserTokenURL),
         groundedLanguageModel: (modelId) => new GeminiGroundedLanguageModel(modelId, apiKey, baseURL, fetcher),
+        files: new GeminiFilesClient(apiKey, baseURL, fetcher),
+        fileSearchStores: new GeminiFileSearchStoresClient(apiKey, baseURL, fetcher),
+        caches: new GeminiContextCachesClient(apiKey, baseURL, fetcher),
+        batches: new GeminiBatchesClient(apiKey, baseURL, fetcher),
+        interactions: new GeminiInteractionsClient(apiKey, baseURL, fetcher),
+        predictionModel: (modelId) => new GeminiPredictionModel(modelId, apiKey, baseURL, fetcher),
         rawFetch: fetcher
     });
 };