@ai-sdk/google 3.0.67 → 3.0.68

package/src/interactions/synthesize-google-interactions-agent-stream.ts

@@ -0,0 +1,185 @@
+import type {
+  LanguageModelV3FinishReason,
+  LanguageModelV3StreamPart,
+  SharedV3ProviderMetadata,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import { convertGoogleInteractionsUsage } from './convert-google-interactions-usage';
+import { type GoogleInteractionsResponse } from './google-interactions-api';
+import { mapGoogleInteractionsFinishReason } from './map-google-interactions-finish-reason';
+import { parseGoogleInteractionsOutputs } from './parse-google-interactions-outputs';
+
+/**
+ * Synthesizes a `LanguageModelV3StreamPart` stream from a fully-resolved
+ * Interaction response (i.e. the `response` returned after polling a
+ * `background: true` agent call to a terminal status).
+ *
+ * Agent calls cannot use SSE (`stream: true` is incompatible with
+ * `background: true`), so we deterministically replay the polled outputs as a
+ * stream sequence in the same order/shape `buildGoogleInteractionsStreamTransform`
+ * would produce. Each text/reasoning block is emitted as a single delta — the
+ * server has already produced the whole block by the time we synthesize.
+ */
+export function synthesizeGoogleInteractionsAgentStream({
+  response,
+  warnings,
+  generateId,
+  includeRawChunks,
+  headerServiceTier,
+}: {
+  response: GoogleInteractionsResponse;
+  warnings: Array<SharedV3Warning>;
+  generateId: () => string;
+  includeRawChunks?: boolean;
+  headerServiceTier?: string;
+}): ReadableStream<LanguageModelV3StreamPart> {
+  return new ReadableStream<LanguageModelV3StreamPart>({
+    start(controller) {
+      controller.enqueue({ type: 'stream-start', warnings });
+
+      const interactionId =
+        typeof response.id === 'string' && response.id.length > 0
+          ? response.id
+          : undefined;
+
+      let timestamp: Date | undefined;
+      const created = response.created;
+      if (typeof created === 'string') {
+        const parsed = new Date(created);
+        if (!Number.isNaN(parsed.getTime())) {
+          timestamp = parsed;
+        }
+      }
+
+      controller.enqueue({
+        type: 'response-metadata',
+        ...(interactionId != null ? { id: interactionId } : {}),
+        modelId: response.model ?? undefined,
+        ...(timestamp ? { timestamp } : {}),
+      });
+
+      if (includeRawChunks) {
+        controller.enqueue({ type: 'raw', rawValue: response });
+      }
+
+      const { content, hasFunctionCall } = parseGoogleInteractionsOutputs({
+        outputs: response.outputs ?? null,
+        generateId,
+        interactionId,
+      });
+
+      let blockCounter = 0;
+      const nextBlockId = () => `${interactionId ?? 'agent'}:${blockCounter++}`;
+
+      for (const part of content) {
+        switch (part.type) {
+          case 'text': {
+            const id = nextBlockId();
+            const providerMetadata = part.providerMetadata;
+            controller.enqueue({ type: 'text-start', id });
+            if (part.text.length > 0) {
+              controller.enqueue({ type: 'text-delta', id, delta: part.text });
+            }
+            controller.enqueue({
+              type: 'text-end',
+              id,
+              ...(providerMetadata ? { providerMetadata } : {}),
+            });
+            break;
+          }
+          case 'reasoning': {
+            const id = nextBlockId();
+            const providerMetadata = part.providerMetadata;
+            controller.enqueue({ type: 'reasoning-start', id });
+            if (part.text.length > 0) {
+              controller.enqueue({
+                type: 'reasoning-delta',
+                id,
+                delta: part.text,
+              });
+            }
+            controller.enqueue({
+              type: 'reasoning-end',
+              id,
+              ...(providerMetadata ? { providerMetadata } : {}),
+            });
+            break;
+          }
+          case 'tool-call': {
+            const providerMetadata = part.providerMetadata;
+            controller.enqueue({
+              type: 'tool-input-start',
+              id: part.toolCallId,
+              toolName: part.toolName,
+              ...(part.providerExecuted
+                ? { providerExecuted: part.providerExecuted }
+                : {}),
+            });
+            controller.enqueue({
+              type: 'tool-input-delta',
+              id: part.toolCallId,
+              delta: part.input,
+            });
+            controller.enqueue({
+              type: 'tool-input-end',
+              id: part.toolCallId,
+            });
+            controller.enqueue({
+              type: 'tool-call',
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input,
+              ...(part.providerExecuted
+                ? { providerExecuted: part.providerExecuted }
+                : {}),
+              ...(providerMetadata ? { providerMetadata } : {}),
+            });
+            break;
+          }
+          case 'tool-result': {
+            controller.enqueue({
+              type: 'tool-result',
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              result: part.result,
+            });
+            break;
+          }
+          case 'source':
+          case 'file': {
+            controller.enqueue(part);
+            break;
+          }
+          default:
+            break;
+        }
+      }
+
+      const serviceTier = response.service_tier ?? headerServiceTier;
+
+      const finishReason: LanguageModelV3FinishReason = {
+        unified: mapGoogleInteractionsFinishReason({
+          status: response.status,
+          hasFunctionCall,
+        }),
+        raw: response.status,
+      };
+
+      const providerMetadata: SharedV3ProviderMetadata = {
+        google: {
+          ...(interactionId != null ? { interactionId } : {}),
+          ...(serviceTier != null ? { serviceTier } : {}),
+        },
+      };
+
+      controller.enqueue({
+        type: 'finish',
+        finishReason,
+        usage: convertGoogleInteractionsUsage(response.usage),
+        providerMetadata,
+      });
+
+      controller.close();
+    },
+  });
+}