ai-sdk-provider-claude-code 3.3.2 → 3.3.4

package/README.md

@@ -310,6 +310,68 @@ const model = claudeCode('sonnet', {
 });
 ```
 
+## Mid-Session Message Injection
+
+This provider supports **mid-session message injection** for supervisor patterns, allowing you to interrupt, redirect, or provide feedback to an agent during execution.
+
+```typescript
+import { streamText } from 'ai';
+import { claudeCode, type MessageInjector } from 'ai-sdk-provider-claude-code';
+
+let injector: MessageInjector | null = null;
+
+const result = streamText({
+  model: claudeCode('haiku', {
+    streamingInput: 'always', // Required for injection
+    onStreamStart: (inj) => {
+      injector = inj;
+
+      // Example: Inject after 5 seconds
+      setTimeout(() => {
+        injector?.inject('STOP! Change of plans - do something else.');
+      }, 5000);
+    },
+  }),
+  prompt: 'Write 10 files with poems...',
+});
+
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+**Requirements:**
+
+- `streamingInput: 'always'` or `'auto'` with `canUseTool` set
+- Messages injected via `inject(content)` are delivered to the agent mid-turn
+
+**Important:** Injection works between tool calls, not during continuous text generation. Use tasks that involve tool usage (file operations, bash commands, etc.) for effective mid-turn interruption.
+
+**Use Cases:**
+
+- Stop an agent mid-task
+- Redirect to a different goal
+- Provide real-time feedback
+- Implement human-in-the-loop approval workflows
+
+**API:**
+
+- `inject(content: string, onResult?: (delivered: boolean) => void)` - Inject a user message. Optional callback reports delivery status.
+- `close()` - Signal no more messages will be injected
+
+**Delivery Tracking:**
+
+```typescript
+injector.inject('STOP!', (delivered) => {
+  if (!delivered) {
+    // Session ended before message was delivered
+    // Handle retry via session resume, etc.
+  }
+});
+```
+
+See [examples/message-injection.ts](examples/message-injection.ts) for complete examples including conditional injection and supervisor approval patterns.
+
 ## Image Inputs (Streaming Only)
 
 - Enable streaming input (`streamingInput: 'always'` or provide `canUseTool`) before sending images.

package/dist/index.cjs

@@ -572,6 +572,9 @@ var claudeCodeSettingsSchema = import_zod.z.object({
   // Callback invoked when Query object is created - for mid-stream injection via streamInput()
   onQueryCreated: import_zod.z.any().refine((val) => val === void 0 || typeof val === "function", {
     message: "onQueryCreated must be a function"
+  }).optional(),
+  onStreamStart: import_zod.z.any().refine((val) => val === void 0 || typeof val === "function", {
+    message: "onStreamStart must be a function"
   }).optional()
 }).strict();
 function validateModelId(modelId) {
@@ -806,9 +809,66 @@ function convertClaudeCodeUsage(usage) {
     raw: usage
   };
 }
-function toAsyncIterablePrompt(messagesPrompt, outputStreamEnded, sessionId, contentParts) {
+function createMessageInjector() {
+  const queue = [];
+  let closed = false;
+  let resolver = null;
+  const injector = {
+    inject(content, onResult) {
+      if (closed) {
+        onResult?.(false);
+        return;
+      }
+      const item = { content, onResult };
+      if (resolver) {
+        const r = resolver;
+        resolver = null;
+        r(item);
+      } else {
+        queue.push(item);
+      }
+    },
+    close() {
+      closed = true;
+      if (resolver && queue.length === 0) {
+        resolver(null);
+        resolver = null;
+      }
+    }
+  };
+  const getNextItem = () => {
+    if (queue.length > 0) {
+      const item = queue.shift();
+      if (!item) {
+        return Promise.resolve(null);
+      }
+      return Promise.resolve(item);
+    }
+    if (closed) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+      resolver = (item) => {
+        resolve(item);
+      };
+    });
+  };
+  const notifySessionEnded = () => {
+    for (const item of queue) {
+      item.onResult?.(false);
+    }
+    queue.length = 0;
+    closed = true;
+    if (resolver) {
+      resolver(null);
+      resolver = null;
+    }
+  };
+  return { injector, getNextItem, notifySessionEnded };
+}
+function toAsyncIterablePrompt(messagesPrompt, outputStreamEnded, sessionId, contentParts, onStreamStart) {
   const content = contentParts && contentParts.length > 0 ? contentParts : [{ type: "text", text: messagesPrompt }];
-  const msg = {
+  const initialMsg = {
     type: "user",
     message: {
       role: "user",
@@ -817,10 +877,42 @@ function toAsyncIterablePrompt(messagesPrompt, outputStreamEnded, sessionId, con
     parent_tool_use_id: null,
     session_id: sessionId ?? ""
   };
+  if (!onStreamStart) {
+    return {
+      async *[Symbol.asyncIterator]() {
+        yield initialMsg;
+        await outputStreamEnded;
+      }
+    };
+  }
+  const { injector, getNextItem, notifySessionEnded } = createMessageInjector();
   return {
     async *[Symbol.asyncIterator]() {
-      yield msg;
-      await outputStreamEnded;
+      yield initialMsg;
+      onStreamStart(injector);
+      let streamEnded = false;
+      void outputStreamEnded.then(() => {
+        streamEnded = true;
+        notifySessionEnded();
+      });
+      while (!streamEnded) {
+        const item = await Promise.race([getNextItem(), outputStreamEnded.then(() => null)]);
+        if (item === null) {
+          await outputStreamEnded;
+          break;
+        }
+        const sdkMsg = {
+          type: "user",
+          message: {
+            role: "user",
+            content: [{ type: "text", text: item.content }]
+          },
+          parent_tool_use_id: null,
+          session_id: sessionId ?? ""
+        };
+        yield sdkMsg;
+        item.onResult?.(true);
+      }
     }
   };
 }
@@ -1293,6 +1385,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     let wasTruncated = false;
     let costUsd;
     let durationMs;
+    let modelUsage;
     const warnings = this.generateAllWarnings(options, messagesPrompt);
     if (messageWarnings) {
       messageWarnings.forEach((warning) => {
@@ -1327,7 +1420,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         messagesPrompt,
         outputStreamEnded,
         effectiveResume,
-        streamingContentParts
+        streamingContentParts,
+        this.settings.onStreamStart
       ) : messagesPrompt;
       this.logger.debug(
         `[claude-code] Executing query with streamingInput: ${wantsStreamInput}, session: ${effectiveResume ?? "new"}`
@@ -1346,6 +1440,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           this.setSessionId(message.session_id);
           costUsd = message.total_cost_usd;
           durationMs = message.duration_ms;
+          modelUsage = message.modelUsage;
           if ("is_error" in message && message.is_error === true) {
             const errorMessage = "result" in message && typeof message.result === "string" ? message.result : "Claude Code CLI returned an error";
             throw Object.assign(new Error(errorMessage), { exitCode: 1 });
@@ -1421,6 +1516,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           ...this.sessionId !== void 0 && { sessionId: this.sessionId },
           ...costUsd !== void 0 && { costUsd },
           ...durationMs !== void 0 && { durationMs },
+          ...modelUsage !== void 0 && { modelUsage },
           ...wasTruncated && { truncated: true }
         }
       }
@@ -1560,7 +1656,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
             messagesPrompt,
             outputStreamEnded,
             effectiveResume,
-            streamingContentParts
+            streamingContentParts,
+            this.settings.onStreamStart
           ) : messagesPrompt;
           this.logger.debug(
             `[claude-code] Starting stream query with streamingInput: ${wantsStreamInput}, session: ${effectiveResume ?? "new"}`
@@ -2155,6 +2252,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                       costUsd: message.total_cost_usd
                     },
                     ...message.duration_ms !== void 0 && { durationMs: message.duration_ms },
+                    ...message.modelUsage !== void 0 && {
+                      modelUsage: message.modelUsage
+                    },
                     // JSON validation warnings are collected during streaming and included
                     // in providerMetadata since the AI SDK's finish event doesn't support
                     // a top-level warnings field (unlike stream-start which was already emitted)