ai-sdk-provider-claude-code 3.3.3 → 3.3.5

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);
+      }
     }
   };
 }
@@ -1328,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"}`
@@ -1563,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"}`
@@ -1938,6 +2032,23 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 );
                 continue;
               }
+              if (textPartId) {
+                const closedTextId = textPartId;
+                controller.enqueue({
+                  type: "text-end",
+                  id: closedTextId
+                });
+                textPartId = void 0;
+                for (const [blockIndex, blockTextId] of textBlocksByIndex) {
+                  if (blockTextId === closedTextId) {
+                    textBlocksByIndex.delete(blockIndex);
+                    break;
+                  }
+                }
+                accumulatedText = "";
+                streamedTextLength = 0;
+                this.logger.debug("[claude-code] Closed text part due to user message");
+              }
               const sdkParentToolUseIdForResults = message.parent_tool_use_id;
               const content = message.message.content;
               for (const result of this.extractToolResults(content)) {