google-antigravity-ai-provider 0.0.2

package/README.md

@@ -0,0 +1,35 @@
+# AI SDK - Google Generative AI Provider
+
+The **[Google Generative AI provider](https://ai-sdk.dev/providers/ai-sdk-providers/google-generative-ai)** for the [AI SDK](https://ai-sdk.dev/docs) contains language model support for the [Google Generative AI](https://ai.google/discover/generativeai/) APIs.
+
+## Setup
+
+The Google Generative AI provider is available in the `@ai-sdk/google` module. You can install it with
+
+```bash
+npm i @ai-sdk/google
+```
+
+## Provider Instance
+
+You can import the default provider instance `google` from `@ai-sdk/google`:
+
+```ts
+import { google } from '@ai-sdk/google';
+```
+
+## Example
+
+```ts
+import { google } from '@ai-sdk/google';
+import { generateText } from 'ai';
+
+const { text } = await generateText({
+  model: google('gemini-1.5-pro-latest'),
+  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
+});
+```
+
+## Documentation
+
+Please check out the **[Google Generative AI provider documentation](https://ai-sdk.dev/providers/ai-sdk-providers/google-generative-ai)** for more information.

package/dist/convert-google-generative-ai-usage.d.ts

@@ -0,0 +1,11 @@
+import { LanguageModelV3Usage } from '@ai-sdk/provider';
+export type GoogleGenerativeAIUsageMetadata = {
+    promptTokenCount?: number | null;
+    candidatesTokenCount?: number | null;
+    totalTokenCount?: number | null;
+    cachedContentTokenCount?: number | null;
+    thoughtsTokenCount?: number | null;
+    trafficType?: string | null;
+};
+export declare function convertGoogleGenerativeAIUsage(usage: GoogleGenerativeAIUsageMetadata | undefined | null): LanguageModelV3Usage;
+//# sourceMappingURL=convert-google-generative-ai-usage.d.ts.map

package/dist/convert-google-generative-ai-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-google-generative-ai-usage.d.ts","sourceRoot":"","sources":["../src/convert-google-generative-ai-usage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,uBAAuB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,+BAA+B,GAAG,SAAS,GAAG,IAAI,GACxD,oBAAoB,CAqCtB"}

package/dist/convert-google-generative-ai-usage.js

@@ -0,0 +1,37 @@
+export function convertGoogleGenerativeAIUsage(usage) {
+    var _a, _b, _c, _d;
+    if (usage == null) {
+        return {
+            inputTokens: {
+                total: undefined,
+                noCache: undefined,
+                cacheRead: undefined,
+                cacheWrite: undefined,
+            },
+            outputTokens: {
+                total: undefined,
+                text: undefined,
+                reasoning: undefined,
+            },
+            raw: undefined,
+        };
+    }
+    const promptTokens = (_a = usage.promptTokenCount) !== null && _a !== void 0 ? _a : 0;
+    const candidatesTokens = (_b = usage.candidatesTokenCount) !== null && _b !== void 0 ? _b : 0;
+    const cachedContentTokens = (_c = usage.cachedContentTokenCount) !== null && _c !== void 0 ? _c : 0;
+    const thoughtsTokens = (_d = usage.thoughtsTokenCount) !== null && _d !== void 0 ? _d : 0;
+    return {
+        inputTokens: {
+            total: promptTokens,
+            noCache: promptTokens - cachedContentTokens,
+            cacheRead: cachedContentTokens,
+            cacheWrite: undefined,
+        },
+        outputTokens: {
+            total: candidatesTokens + thoughtsTokens,
+            text: candidatesTokens,
+            reasoning: thoughtsTokens,
+        },
+        raw: usage,
+    };
+}

package/dist/convert-json-schema-to-openapi-schema.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchema7Definition } from '@ai-sdk/provider';
+/**
+ * Converts JSON Schema 7 to OpenAPI Schema 3.0
+ */
+export declare function convertJSONSchemaToOpenAPISchema(jsonSchema: JSONSchema7Definition | undefined, isRoot?: boolean): unknown;
+//# sourceMappingURL=convert-json-schema-to-openapi-schema.d.ts.map

package/dist/convert-json-schema-to-openapi-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-json-schema-to-openapi-schema.d.ts","sourceRoot":"","sources":["../src/convert-json-schema-to-openapi-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,qBAAqB,GAAG,SAAS,EAC7C,MAAM,UAAO,GACZ,OAAO,CA0IT"}

package/dist/convert-json-schema-to-openapi-schema.js

@@ -0,0 +1,108 @@
+/**
+ * Converts JSON Schema 7 to OpenAPI Schema 3.0
+ */
+export function convertJSONSchemaToOpenAPISchema(jsonSchema, isRoot = true) {
+    // Handle empty object schemas: undefined at root, preserved when nested
+    if (jsonSchema == null) {
+        return undefined;
+    }
+    if (isEmptyObjectSchema(jsonSchema)) {
+        if (isRoot) {
+            return undefined;
+        }
+        if (typeof jsonSchema === 'object' && jsonSchema.description) {
+            return { type: 'object', description: jsonSchema.description };
+        }
+        return { type: 'object' };
+    }
+    if (typeof jsonSchema === 'boolean') {
+        return { type: 'boolean', properties: {} };
+    }
+    const { type, description, required, properties, items, allOf, anyOf, oneOf, format, const: constValue, minLength, enum: enumValues, } = jsonSchema;
+    const result = {};
+    if (description)
+        result.description = description;
+    if (required)
+        result.required = required;
+    if (format)
+        result.format = format;
+    if (constValue !== undefined) {
+        result.enum = [constValue];
+    }
+    // Handle type
+    if (type) {
+        if (Array.isArray(type)) {
+            const hasNull = type.includes('null');
+            const nonNullTypes = type.filter(t => t !== 'null');
+            if (nonNullTypes.length === 0) {
+                // Only null type
+                result.type = 'null';
+            }
+            else {
+                // One or more non-null types: always use anyOf
+                result.anyOf = nonNullTypes.map(t => ({ type: t }));
+                if (hasNull) {
+                    result.nullable = true;
+                }
+            }
+        }
+        else {
+            result.type = type;
+        }
+    }
+    // Handle enum
+    if (enumValues !== undefined) {
+        result.enum = enumValues;
+    }
+    if (properties != null) {
+        result.properties = Object.entries(properties).reduce((acc, [key, value]) => {
+            acc[key] = convertJSONSchemaToOpenAPISchema(value, false);
+            return acc;
+        }, {});
+    }
+    if (items) {
+        result.items = Array.isArray(items)
+            ? items.map(item => convertJSONSchemaToOpenAPISchema(item, false))
+            : convertJSONSchemaToOpenAPISchema(items, false);
+    }
+    if (allOf) {
+        result.allOf = allOf.map(item => convertJSONSchemaToOpenAPISchema(item, false));
+    }
+    if (anyOf) {
+        // Handle cases where anyOf includes a null type
+        if (anyOf.some(schema => typeof schema === 'object' && (schema === null || schema === void 0 ? void 0 : schema.type) === 'null')) {
+            const nonNullSchemas = anyOf.filter(schema => !(typeof schema === 'object' && (schema === null || schema === void 0 ? void 0 : schema.type) === 'null'));
+            if (nonNullSchemas.length === 1) {
+                // If there's only one non-null schema, convert it and make it nullable
+                const converted = convertJSONSchemaToOpenAPISchema(nonNullSchemas[0], false);
+                if (typeof converted === 'object') {
+                    result.nullable = true;
+                    Object.assign(result, converted);
+                }
+            }
+            else {
+                // If there are multiple non-null schemas, keep them in anyOf
+                result.anyOf = nonNullSchemas.map(item => convertJSONSchemaToOpenAPISchema(item, false));
+                result.nullable = true;
+            }
+        }
+        else {
+            result.anyOf = anyOf.map(item => convertJSONSchemaToOpenAPISchema(item, false));
+        }
+    }
+    if (oneOf) {
+        result.oneOf = oneOf.map(item => convertJSONSchemaToOpenAPISchema(item, false));
+    }
+    if (minLength !== undefined) {
+        result.minLength = minLength;
+    }
+    return result;
+}
+function isEmptyObjectSchema(jsonSchema) {
+    return (jsonSchema != null &&
+        typeof jsonSchema === 'object' &&
+        jsonSchema.type === 'object' &&
+        (jsonSchema.properties == null ||
+            Object.keys(jsonSchema.properties).length === 0) &&
+        !jsonSchema.additionalProperties);
+}

package/dist/convert-to-google-generative-ai-messages.d.ts

@@ -0,0 +1,7 @@
+import { LanguageModelV3Prompt } from '@ai-sdk/provider';
+import { GoogleGenerativeAIPrompt } from './google-generative-ai-prompt';
+export declare function convertToGoogleGenerativeAIMessages(prompt: LanguageModelV3Prompt, options?: {
+    isGemmaModel?: boolean;
+    providerOptionsName?: string;
+}): GoogleGenerativeAIPrompt;
+//# sourceMappingURL=convert-to-google-generative-ai-messages.d.ts.map

package/dist/convert-to-google-generative-ai-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-to-google-generative-ai-messages.d.ts","sourceRoot":"","sources":["../src/convert-to-google-generative-ai-messages.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EAEtB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAGL,wBAAwB,EACzB,MAAM,+BAA+B,CAAC;AAGvC,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,qBAAqB,EAC7B,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAE,GACjE,wBAAwB,CAyN1B"}

package/dist/convert-to-google-generative-ai-messages.js

@@ -0,0 +1,186 @@
+import { UnsupportedFunctionalityError, } from '@ai-sdk/provider';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+export function convertToGoogleGenerativeAIMessages(prompt, options) {
+    var _a, _b, _c;
+    const systemInstructionParts = [];
+    const contents = [];
+    let systemMessagesAllowed = true;
+    const isGemmaModel = (_a = options === null || options === void 0 ? void 0 : options.isGemmaModel) !== null && _a !== void 0 ? _a : false;
+    const providerOptionsName = (_b = options === null || options === void 0 ? void 0 : options.providerOptionsName) !== null && _b !== void 0 ? _b : 'google';
+    for (const { role, content } of prompt) {
+        switch (role) {
+            case 'system': {
+                if (!systemMessagesAllowed) {
+                    throw new UnsupportedFunctionalityError({
+                        functionality: 'system messages are only supported at the beginning of the conversation',
+                    });
+                }
+                systemInstructionParts.push({ text: content });
+                break;
+            }
+            case 'user': {
+                systemMessagesAllowed = false;
+                const parts = [];
+                for (const part of content) {
+                    switch (part.type) {
+                        case 'text': {
+                            parts.push({ text: part.text });
+                            break;
+                        }
+                        case 'file': {
+                            // default to image/jpeg for unknown image/* types
+                            const mediaType = part.mediaType === 'image/*' ? 'image/jpeg' : part.mediaType;
+                            parts.push(part.data instanceof URL
+                                ? {
+                                    fileData: {
+                                        mimeType: mediaType,
+                                        fileUri: part.data.toString(),
+                                    },
+                                }
+                                : {
+                                    inlineData: {
+                                        mimeType: mediaType,
+                                        data: convertToBase64(part.data),
+                                    },
+                                });
+                            break;
+                        }
+                    }
+                }
+                contents.push({ role: 'user', parts });
+                break;
+            }
+            case 'assistant': {
+                systemMessagesAllowed = false;
+                contents.push({
+                    role: 'model',
+                    parts: content
+                        .map(part => {
+                        var _a;
+                        const providerOpts = (_a = part.providerOptions) === null || _a === void 0 ? void 0 : _a[providerOptionsName];
+                        const thoughtSignature = (providerOpts === null || providerOpts === void 0 ? void 0 : providerOpts.thoughtSignature) != null
+                            ? String(providerOpts.thoughtSignature)
+                            : undefined;
+                        switch (part.type) {
+                            case 'text': {
+                                return part.text.length === 0
+                                    ? undefined
+                                    : {
+                                        text: part.text,
+                                        thoughtSignature,
+                                    };
+                            }
+                            case 'reasoning': {
+                                return part.text.length === 0
+                                    ? undefined
+                                    : {
+                                        text: part.text,
+                                        thought: true,
+                                        thoughtSignature,
+                                    };
+                            }
+                            case 'file': {
+                                if (part.data instanceof URL) {
+                                    throw new UnsupportedFunctionalityError({
+                                        functionality: 'File data URLs in assistant messages are not supported',
+                                    });
+                                }
+                                return {
+                                    inlineData: {
+                                        mimeType: part.mediaType,
+                                        data: convertToBase64(part.data),
+                                    },
+                                    thoughtSignature,
+                                };
+                            }
+                            case 'tool-call': {
+                                return {
+                                    functionCall: {
+                                        name: part.toolName,
+                                        args: part.input,
+                                    },
+                                    thoughtSignature,
+                                };
+                            }
+                        }
+                    })
+                        .filter(part => part !== undefined),
+                });
+                break;
+            }
+            case 'tool': {
+                systemMessagesAllowed = false;
+                const parts = [];
+                for (const part of content) {
+                    if (part.type === 'tool-approval-response') {
+                        continue;
+                    }
+                    const output = part.output;
+                    if (output.type === 'content') {
+                        for (const contentPart of output.value) {
+                            switch (contentPart.type) {
+                                case 'text':
+                                    parts.push({
+                                        functionResponse: {
+                                            name: part.toolName,
+                                            response: {
+                                                name: part.toolName,
+                                                content: contentPart.text,
+                                            },
+                                        },
+                                    });
+                                    break;
+                                case 'image-data':
+                                    parts.push({
+                                        inlineData: {
+                                            mimeType: contentPart.mediaType,
+                                            data: contentPart.data,
+                                        },
+                                    }, {
+                                        text: 'Tool executed successfully and returned this image as a response',
+                                    });
+                                    break;
+                                default:
+                                    parts.push({ text: JSON.stringify(contentPart) });
+                                    break;
+                            }
+                        }
+                    }
+                    else {
+                        parts.push({
+                            functionResponse: {
+                                name: part.toolName,
+                                response: {
+                                    name: part.toolName,
+                                    content: output.type === 'execution-denied'
+                                        ? ((_c = output.reason) !== null && _c !== void 0 ? _c : 'Tool execution denied.')
+                                        : output.value,
+                                },
+                            },
+                        });
+                    }
+                }
+                contents.push({
+                    role: 'user',
+                    parts,
+                });
+                break;
+            }
+        }
+    }
+    if (isGemmaModel &&
+        systemInstructionParts.length > 0 &&
+        contents.length > 0 &&
+        contents[0].role === 'user') {
+        const systemText = systemInstructionParts
+            .map(part => part.text)
+            .join('\n\n');
+        contents[0].parts.unshift({ text: systemText + '\n\n' });
+    }
+    return {
+        systemInstruction: systemInstructionParts.length > 0 && !isGemmaModel
+            ? { parts: systemInstructionParts }
+            : undefined,
+        contents,
+    };
+}

package/dist/get-model-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getModelPath(modelId: string): string;
+//# sourceMappingURL=get-model-path.d.ts.map

package/dist/get-model-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-model-path.d.ts","sourceRoot":"","sources":["../src/get-model-path.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/get-model-path.js

@@ -0,0 +1,3 @@
+export function getModelPath(modelId) {
+    return modelId.includes('/') ? modelId : `models/${modelId}`;
+}

package/dist/google-antigravity-language-model.d.ts

@@ -0,0 +1,185 @@
+import { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult } from '@ai-sdk/provider';
+import { FetchFunction, InferSchema, Resolvable } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { GoogleAntigravityModelId } from './google-antigravity-options';
+type GoogleGenerativeAIConfig = {
+    provider: string;
+    baseURL: string;
+    headers: Resolvable<Record<string, string | undefined>>;
+    fetch?: FetchFunction;
+    generateId: () => string;
+    /**
+     * The supported URLs for the model.
+     */
+    supportedUrls?: () => LanguageModelV3['supportedUrls'];
+};
+export declare class GoogleAntigravityLanguageModel implements LanguageModelV3 {
+    readonly specificationVersion = "v3";
+    readonly modelId: GoogleAntigravityModelId;
+    private readonly config;
+    private readonly generateId;
+    constructor(modelId: GoogleAntigravityModelId, config: GoogleGenerativeAIConfig);
+    get provider(): string;
+    get supportedUrls(): Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>>;
+    private get isClaudeModel();
+    private getArgs;
+    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
+    doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
+}
+export declare const getGroundingMetadataSchema: () => z.ZodObject<{
+    webSearchQueries: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    retrievalQueries: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    searchEntryPoint: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        renderedContent: z.ZodString;
+    }, z.core.$strip>>>;
+    groundingChunks: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        web: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            uri: z.ZodString;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        retrievedContext: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            uri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            fileSearchStore: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        maps: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            uri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            placeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>>;
+    groundingSupports: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        segment: z.ZodObject<{
+            startIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            endIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        segment_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        groundingChunkIndices: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+        supportChunkIndices: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+        confidenceScores: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+        confidenceScore: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+    }, z.core.$strip>>>>;
+    retrievalMetadata: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        webDynamicRetrievalScore: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export declare const getUrlContextMetadataSchema: () => z.ZodObject<{
+    urlMetadata: z.ZodArray<z.ZodObject<{
+        retrievedUrl: z.ZodString;
+        urlRetrievalStatus: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const responseSchema: import("@ai-sdk/provider-utils").LazySchema<{
+    candidates: {
+        content?: Record<string, never> | {
+            parts?: ({
+                functionCall: {
+                    name: string;
+                    args: unknown;
+                    id?: string | null | undefined;
+                };
+                thoughtSignature?: string | null | undefined;
+            } | {
+                inlineData: {
+                    mimeType: string;
+                    data: string;
+                };
+                thoughtSignature?: string | null | undefined;
+            } | {
+                executableCode?: {
+                    language: string;
+                    code: string;
+                } | null | undefined;
+                codeExecutionResult?: {
+                    outcome: string;
+                    output: string;
+                } | null | undefined;
+                text?: string | null | undefined;
+                thought?: boolean | null | undefined;
+                thoughtSignature?: string | null | undefined;
+            })[] | null | undefined;
+        } | null | undefined;
+        finishReason?: string | null | undefined;
+        safetyRatings?: {
+            category?: string | null | undefined;
+            probability?: string | null | undefined;
+            probabilityScore?: number | null | undefined;
+            severity?: string | null | undefined;
+            severityScore?: number | null | undefined;
+            blocked?: boolean | null | undefined;
+        }[] | null | undefined;
+        groundingMetadata?: {
+            webSearchQueries?: string[] | null | undefined;
+            retrievalQueries?: string[] | null | undefined;
+            searchEntryPoint?: {
+                renderedContent: string;
+            } | null | undefined;
+            groundingChunks?: {
+                web?: {
+                    uri: string;
+                    title?: string | null | undefined;
+                } | null | undefined;
+                retrievedContext?: {
+                    uri?: string | null | undefined;
+                    title?: string | null | undefined;
+                    text?: string | null | undefined;
+                    fileSearchStore?: string | null | undefined;
+                } | null | undefined;
+                maps?: {
+                    uri?: string | null | undefined;
+                    title?: string | null | undefined;
+                    text?: string | null | undefined;
+                    placeId?: string | null | undefined;
+                } | null | undefined;
+            }[] | null | undefined;
+            groundingSupports?: {
+                segment: {
+                    startIndex?: number | null | undefined;
+                    endIndex?: number | null | undefined;
+                    text?: string | null | undefined;
+                };
+                segment_text?: string | null | undefined;
+                groundingChunkIndices?: number[] | null | undefined;
+                supportChunkIndices?: number[] | null | undefined;
+                confidenceScores?: number[] | null | undefined;
+                confidenceScore?: number[] | null | undefined;
+            }[] | null | undefined;
+            retrievalMetadata?: Record<string, never> | {
+                webDynamicRetrievalScore: number;
+            } | null | undefined;
+        } | null | undefined;
+        urlContextMetadata?: {
+            urlMetadata: {
+                retrievedUrl: string;
+                urlRetrievalStatus: string;
+            }[];
+        } | null | undefined;
+    }[];
+    usageMetadata?: {
+        cachedContentTokenCount?: number | null | undefined;
+        thoughtsTokenCount?: number | null | undefined;
+        promptTokenCount?: number | null | undefined;
+        candidatesTokenCount?: number | null | undefined;
+        totalTokenCount?: number | null | undefined;
+        trafficType?: string | null | undefined;
+    } | null | undefined;
+    promptFeedback?: {
+        blockReason?: string | null | undefined;
+        safetyRatings?: {
+            category?: string | null | undefined;
+            probability?: string | null | undefined;
+            probabilityScore?: number | null | undefined;
+            severity?: string | null | undefined;
+            severityScore?: number | null | undefined;
+            blocked?: boolean | null | undefined;
+        }[] | null | undefined;
+    } | null | undefined;
+}>;
+export type GroundingMetadataSchema = NonNullable<InferSchema<typeof responseSchema>['candidates'][number]['groundingMetadata']>;
+export type UrlContextMetadataSchema = NonNullable<InferSchema<typeof responseSchema>['candidates'][number]['urlContextMetadata']>;
+export type SafetyRatingSchema = NonNullable<InferSchema<typeof responseSchema>['candidates'][number]['safetyRatings']>[number];
+export {};
+//# sourceMappingURL=google-antigravity-language-model.d.ts.map

package/dist/google-antigravity-language-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-antigravity-language-model.d.ts","sourceRoot":"","sources":["../src/google-antigravity-language-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAG1B,6BAA6B,EAG7B,2BAA2B,EAG5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAIL,aAAa,EAEb,WAAW,EAKX,UAAU,EAGX,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAS3B,OAAO,EACL,wBAAwB,EAEzB,MAAM,8BAA8B,CAAC;AAKtC,KAAK,wBAAwB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IACxD,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,MAAM,MAAM,CAAC;IAEzB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,eAAe,CAAC,eAAe,CAAC,CAAC;CACxD,CAAC;AAEF,qBAAa,8BAA+B,YAAW,eAAe;IACpE,QAAQ,CAAC,oBAAoB,QAAQ;IAErC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;IAE3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;gBAGxC,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,wBAAwB;IAOlC,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,aAAa,qEAEhB;IAED,OAAO,KAAK,aAAa,GAExB;YAEa,OAAO;IA6Hf,UAAU,CACd,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,6BAA6B,CAAC;IAkJnC,QAAQ,CACZ,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,2BAA2B,CAAC;CAgUxC;AA4ID,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDnC,CAAC;AAmEL,eAAO,MAAM,2BAA2B;;;;;iBAQpC,CAAC;AAEL,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBnB,CAAC;AAKF,MAAM,MAAM,uBAAuB,GAAG,WAAW,CAC/C,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,mBAAmB,CAAC,CAC9E,CAAC;AAMF,MAAM,MAAM,wBAAwB,GAAG,WAAW,CAChD,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAC/E,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAC1C,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAC1E,CAAC,MAAM,CAAC,CAAC"}