@augmentcode/auggie-sdk 0.1.12 → 0.1.14

package/README.md

@@ -4,6 +4,15 @@ A TypeScript SDK for building AI-powered developer tools with Auggie.
 
 ## Features
 
+### 🎯 AI SDK Provider (Vercel AI SDK)
+**Requires: API credentials only (no local Auggie needed)**
+
+- Use Augment as a language model provider with Vercel's AI SDK
+- Compatible with `generateText`, `streamText`, and other AI SDK functions
+- Full support for tool calling (function calling) with automatic execution
+- Multi-turn conversations with context retention
+- Streaming responses for real-time output
+
 ### 🤖 Agent Interaction (ACP)
 **Requires: Local Auggie installation**
 
@@ -55,6 +64,91 @@ pnpm add /path/to/auggie-sdk
 
 ## Usage
 
+### AI SDK Provider (Vercel AI SDK)
+
+**✅ No Local Auggie Required - API Only**
+
+Use Augment as a language model provider with Vercel's AI SDK:
+
+```typescript
+import { AugmentLanguageModel, resolveAugmentCredentials } from "@augmentcode/auggie-sdk";
+import { generateText } from "ai";
+
+// Resolve credentials from environment or ~/.augment/session.json
+const credentials = await resolveAugmentCredentials();
+
+// Create the Augment language model
+const model = new AugmentLanguageModel("claude-sonnet-4-5", credentials);
+
+// Use with AI SDK functions
+const { text } = await generateText({
+  model,
+  prompt: "Explain TypeScript in one sentence.",
+});
+
+console.log(text);
+```
+
+#### Streaming Responses
+
+```typescript
+import { streamText } from "ai";
+
+const { textStream } = await streamText({
+  model,
+  prompt: "Write a haiku about coding.",
+});
+
+for await (const chunk of textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+#### Tool Calling (Function Calling)
+
+```typescript
+import { generateText, tool } from "ai";
+import { z } from "zod";
+
+const weatherTool = tool({
+  description: "Get the current weather in a location",
+  parameters: z.object({
+    location: z.string(),
+  }),
+  execute: async ({ location }) => {
+    // Your implementation
+    return { temperature: 72, conditions: "sunny" };
+  },
+});
+
+const { text } = await generateText({
+  model,
+  tools: {
+    getWeather: weatherTool,
+  },
+  maxSteps: 5, // Enable multi-step agentic loop
+  prompt: "What's the weather in San Francisco?",
+});
+```
+
+#### Multi-turn Conversations
+
+```typescript
+import { type CoreMessage } from "ai";
+
+const messages: CoreMessage[] = [
+  { role: "user", content: "What is TypeScript?" },
+];
+
+const response1 = await generateText({ model, messages });
+messages.push({ role: "assistant", content: response1.text });
+
+messages.push({ role: "user", content: "What are its benefits?" });
+const response2 = await generateText({ model, messages });
+```
+
+**See [examples/ai-sdk-README.md](examples/ai-sdk-README.md) for more detailed examples.**
+
 ### Agent Interaction (ACP)
 
 **⚠️ Requires Local Auggie Installation**
@@ -312,9 +406,32 @@ const client = await Auggie.create({
   allowIndexing: true,
   apiKey: "your-api-key",  // Optional
   apiUrl: "https://your-tenant.api.augmentcode.com",  // Required when apiKey is provided
+  cliArgs: ["--verbose", "--timeout=30"],  // Optional: Additional CLI arguments
 });
 ```
 
+### Advanced CLI Arguments
+
+The `cliArgs` option allows you to pass additional command-line arguments directly to the Auggie CLI process. These arguments are appended after all SDK-generated flags.
+
+```typescript
+// Pass custom CLI flags
+const client = await Auggie.create({
+  model: "sonnet4.5",
+  cliArgs: ["--verbose", "--log-level=debug"]
+});
+
+// Arguments can use either format:
+// 1. Separate flag and value: ["--timeout", "30"]
+// 2. Combined with equals: ["--timeout=30"]
+const client2 = await Auggie.create({
+  model: "sonnet4.5",
+  cliArgs: ["--timeout=60", "--retries", "3"]
+});
+```
+
+Use this option for advanced configurations or experimental flags not exposed through standard SDK options. Refer to `auggie --help` for available CLI flags.
+
 ## Context Modes
 
 The SDK provides two context modes for codebase indexing and search.
@@ -458,6 +575,7 @@ Creates and initializes a new Auggie instance. This method automatically connect
 - `apiKey?: string` - API key for authentication (optional, sets AUGMENT_API_TOKEN)
 - `apiUrl?: string` - API URL for authentication (optional, sets AUGMENT_API_URL)
 - `excludedTools?: ToolIdentifier[]` - List of tool identifiers to exclude/disable (optional)
+- `cliArgs?: string[]` - Additional command-line arguments to pass to the Auggie CLI process (optional, default: [])
 
 When `tools` (or `toolsMap`) is provided, an MCP server is automatically started and connected to the session.
 

package/dist/auggie/ai-sdk-provider.d.ts

@@ -0,0 +1,106 @@
+import { LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2StreamPart } from '@ai-sdk/provider';
+import { ResolvedCredentials } from '../context/internal/credentials.js';
+
+/**
+ * Augment Language Model - AI SDK LanguageModelV2 implementation using Augment's API.
+ *
+ * This module provides an implementation of the AI SDK's LanguageModelV2 interface
+ * that uses Augment's chat API. It enables using Augment as a model provider with
+ * generateText/streamText from the Vercel AI SDK.
+ *
+ * Supports:
+ * - Text generation
+ * - Tool calling (function tools)
+ * - Multi-turn conversations with tool results
+ * - Streaming responses
+ *
+ * @module auggie/ai-sdk-provider
+ */
+
+/** Configuration for the Augment language model */
+interface AugmentLanguageModelConfig {
+    /** API key for authentication */
+    apiKey: string;
+    /** Augment API URL */
+    apiUrl: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/** Resolved credentials for Augment API (re-export for convenience) */
+type AugmentCredentials = ResolvedCredentials;
+/**
+ * Resolve Augment API credentials from environment variables or session file.
+ *
+ * Priority order:
+ * 1. AUGMENT_API_TOKEN and AUGMENT_API_URL environment variables
+ * 2. ~/.augment/session.json (created by `auggie login`)
+ *
+ * @returns Resolved credentials
+ * @throws Error if credentials cannot be resolved
+ */
+declare function resolveAugmentCredentials(): Promise<AugmentCredentials>;
+/**
+ * Augment Language Model implementation for the AI SDK.
+ *
+ * Implements LanguageModelV2 to enable use with generateText/streamText.
+ * Supports text generation, tool calling, and multi-turn conversations.
+ *
+ * @example
+ * ```typescript
+ * import { AugmentLanguageModel, resolveAugmentCredentials } from "@augmentcode/auggie-sdk";
+ * import { generateText } from "ai";
+ *
+ * const credentials = await resolveAugmentCredentials();
+ * const model = new AugmentLanguageModel("sonnet4.5", credentials);
+ *
+ * const { text } = await generateText({
+ *   model,
+ *   prompt: "Hello, world!",
+ * });
+ * ```
+ *
+ * @example Tool calling with agentic loop
+ * ```typescript
+ * import { generateText, tool } from "ai";
+ * import { z } from "zod";
+ *
+ * const { text, toolCalls } = await generateText({
+ *   model,
+ *   tools: {
+ *     search: tool({
+ *       description: "Search for information",
+ *       parameters: z.object({ query: z.string() }),
+ *       execute: async ({ query }) => searchDatabase(query),
+ *     }),
+ *   },
+ *   maxSteps: 10,
+ *   prompt: "Find information about...",
+ * });
+ * ```
+ */
+declare class AugmentLanguageModel implements LanguageModelV2 {
+    readonly specificationVersion = "v2";
+    readonly provider = "augment";
+    readonly modelId: string;
+    private readonly apiKey;
+    private readonly apiUrl;
+    private readonly sessionId;
+    private readonly debug;
+    constructor(modelId: string, config: AugmentLanguageModelConfig);
+    private log;
+    private getHeaders;
+    private buildPayload;
+    doGenerate(options: LanguageModelV2CallOptions): ReturnType<LanguageModelV2["doGenerate"]>;
+    /**
+     * Parse streaming response and collect content, usage, and finish reason
+     */
+    private parseStreamResponse;
+    doStream(options: LanguageModelV2CallOptions): PromiseLike<{
+        stream: ReadableStream<LanguageModelV2StreamPart>;
+    }>;
+    readonly supportsImageUrls = false;
+    readonly supportsStructuredOutputs = false;
+    readonly supportedUrls: {};
+}
+
+export { type AugmentCredentials, AugmentLanguageModel, type AugmentLanguageModelConfig, resolveAugmentCredentials };

package/dist/auggie/ai-sdk-provider.js

@@ -0,0 +1,515 @@
+import { v4 as uuidv4 } from "uuid";
+import { resolveCredentials } from "../context/internal/credentials.js";
+async function resolveAugmentCredentials() {
+  return resolveCredentials();
+}
+var ChatRequestNodeType = /* @__PURE__ */ ((ChatRequestNodeType2) => {
+  ChatRequestNodeType2[ChatRequestNodeType2["TEXT"] = 0] = "TEXT";
+  ChatRequestNodeType2[ChatRequestNodeType2["TOOL_RESULT"] = 1] = "TOOL_RESULT";
+  ChatRequestNodeType2[ChatRequestNodeType2["IMAGE"] = 2] = "IMAGE";
+  ChatRequestNodeType2[ChatRequestNodeType2["IMAGE_ID"] = 3] = "IMAGE_ID";
+  ChatRequestNodeType2[ChatRequestNodeType2["IDE_STATE"] = 4] = "IDE_STATE";
+  ChatRequestNodeType2[ChatRequestNodeType2["EDIT_EVENTS"] = 5] = "EDIT_EVENTS";
+  return ChatRequestNodeType2;
+})(ChatRequestNodeType || {});
+var ChatResultNodeType = /* @__PURE__ */ ((ChatResultNodeType2) => {
+  ChatResultNodeType2[ChatResultNodeType2["RAW_RESPONSE"] = 0] = "RAW_RESPONSE";
+  ChatResultNodeType2[ChatResultNodeType2["SUGGESTED_QUESTIONS"] = 1] = "SUGGESTED_QUESTIONS";
+  ChatResultNodeType2[ChatResultNodeType2["MAIN_TEXT_FINISHED"] = 2] = "MAIN_TEXT_FINISHED";
+  ChatResultNodeType2[ChatResultNodeType2["WORKSPACE_FILE_CHUNKS"] = 3] = "WORKSPACE_FILE_CHUNKS";
+  ChatResultNodeType2[ChatResultNodeType2["RELEVANT_SOURCES"] = 4] = "RELEVANT_SOURCES";
+  ChatResultNodeType2[ChatResultNodeType2["TOOL_USE"] = 5] = "TOOL_USE";
+  ChatResultNodeType2[ChatResultNodeType2["TOOL_USE_START"] = 7] = "TOOL_USE_START";
+  ChatResultNodeType2[ChatResultNodeType2["THINKING"] = 8] = "THINKING";
+  ChatResultNodeType2[ChatResultNodeType2["BILLING_METADATA"] = 9] = "BILLING_METADATA";
+  ChatResultNodeType2[ChatResultNodeType2["TOKEN_USAGE"] = 10] = "TOKEN_USAGE";
+  return ChatResultNodeType2;
+})(ChatResultNodeType || {});
+var ChatStopReason = /* @__PURE__ */ ((ChatStopReason2) => {
+  ChatStopReason2[ChatStopReason2["REASON_UNSPECIFIED"] = 0] = "REASON_UNSPECIFIED";
+  ChatStopReason2[ChatStopReason2["END_TURN"] = 1] = "END_TURN";
+  ChatStopReason2[ChatStopReason2["MAX_TOKENS"] = 2] = "MAX_TOKENS";
+  ChatStopReason2[ChatStopReason2["TOOL_USE_REQUESTED"] = 3] = "TOOL_USE_REQUESTED";
+  ChatStopReason2[ChatStopReason2["SAFETY"] = 4] = "SAFETY";
+  ChatStopReason2[ChatStopReason2["RECITATION"] = 5] = "RECITATION";
+  ChatStopReason2[ChatStopReason2["MALFORMED_FUNCTION_CALL"] = 6] = "MALFORMED_FUNCTION_CALL";
+  return ChatStopReason2;
+})(ChatStopReason || {});
+function extractText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.filter((p) => typeof p === "object" && p !== null && p.type === "text").map((p) => p.text).join("");
+  }
+  return "";
+}
+function toolsToDefinitions(tools) {
+  if (!tools) return [];
+  return tools.filter((t) => t.type === "function").map((t) => ({
+    name: t.name,
+    description: t.description ?? "",
+    input_schema_json: JSON.stringify(t.inputSchema)
+  }));
+}
+function userMessageToNodes(msg, startId) {
+  const nodes = [];
+  let text = "";
+  let id = startId;
+  if (msg.role !== "user") return { nodes, text };
+  for (const part of msg.content) {
+    if (part.type === "text") {
+      nodes.push({
+        id: id++,
+        type: 0 /* TEXT */,
+        text_node: { content: part.text }
+      });
+      text += part.text;
+    }
+  }
+  return { nodes, text };
+}
+function toolMessageToNodes(msg, startId) {
+  const nodes = [];
+  let id = startId;
+  if (msg.role !== "tool") return nodes;
+  for (const part of msg.content) {
+    if (part.type === "tool-result") {
+      let content = "";
+      let isError = false;
+      const output = part.output;
+      if (output.type === "text") {
+        content = output.value;
+      } else if (output.type === "json") {
+        content = JSON.stringify(output.value);
+      } else if (output.type === "error-text") {
+        content = output.value;
+        isError = true;
+      } else if (output.type === "error-json") {
+        content = JSON.stringify(output.value);
+        isError = true;
+      } else if (output.type === "content") {
+        content = output.value.filter((v) => v.type === "text").map((v) => v.text).join("\n");
+      }
+      nodes.push({
+        id: id++,
+        type: 1 /* TOOL_RESULT */,
+        tool_result_node: {
+          tool_use_id: part.toolCallId,
+          content,
+          is_error: isError
+        }
+      });
+    }
+  }
+  return nodes;
+}
+function assistantMessageToResponseNodes(msg) {
+  const nodes = [];
+  let text = "";
+  let id = 0;
+  if (msg.role !== "assistant") return { nodes, text };
+  for (const part of msg.content) {
+    if (part.type === "text") {
+      text += part.text;
+      nodes.push({
+        id: id++,
+        type: 0 /* RAW_RESPONSE */,
+        content: part.text
+      });
+    } else if (part.type === "tool-call") {
+      nodes.push({
+        id: id++,
+        type: 5 /* TOOL_USE */,
+        tool_use: {
+          tool_use_id: part.toolCallId,
+          tool_name: part.toolName,
+          input_json: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+        }
+      });
+    } else if (part.type === "reasoning") {
+      nodes.push({
+        id: id++,
+        type: 8 /* THINKING */,
+        thinking: { content: part.text }
+      });
+    }
+  }
+  return { nodes, text };
+}
+function buildChatRequest(prompt, tools) {
+  const chatHistory = [];
+  let pendingRequestNodes = [];
+  let pendingRequestText = "";
+  let nodeId = 0;
+  for (const msg of prompt) {
+    if (msg.role === "system") {
+      const systemText = extractText(msg.content);
+      if (systemText) {
+        pendingRequestNodes.push({
+          id: nodeId++,
+          type: 0 /* TEXT */,
+          text_node: { content: `System: ${systemText}` }
+        });
+        pendingRequestText += `System: ${systemText}
+
+`;
+      }
+    } else if (msg.role === "user") {
+      const { nodes, text } = userMessageToNodes(msg, nodeId);
+      pendingRequestNodes.push(...nodes);
+      nodeId += nodes.length;
+      if (pendingRequestText && text) {
+        pendingRequestText += "\n" + text;
+      } else {
+        pendingRequestText += text;
+      }
+    } else if (msg.role === "tool") {
+      const nodes = toolMessageToNodes(msg, nodeId);
+      pendingRequestNodes.push(...nodes);
+      nodeId += nodes.length;
+    } else if (msg.role === "assistant") {
+      const { nodes: responseNodes, text: responseText } = assistantMessageToResponseNodes(msg);
+      chatHistory.push({
+        request_message: pendingRequestText,
+        request_nodes: pendingRequestNodes,
+        response_text: responseText,
+        response_nodes: responseNodes
+      });
+      pendingRequestNodes = [];
+      pendingRequestText = "";
+      nodeId = 0;
+    }
+  }
+  pendingRequestNodes.forEach((node, i) => {
+    node.id = i;
+  });
+  return {
+    message: pendingRequestText,
+    nodes: pendingRequestNodes,
+    chatHistory,
+    toolDefinitions: toolsToDefinitions(tools)
+  };
+}
+function stopReasonToFinishReason(stopReason) {
+  switch (stopReason) {
+    case 1 /* END_TURN */:
+      return "stop";
+    case 2 /* MAX_TOKENS */:
+      return "length";
+    case 3 /* TOOL_USE_REQUESTED */:
+      return "tool-calls";
+    case 4 /* SAFETY */:
+    case 5 /* RECITATION */:
+      return "content-filter";
+    case 6 /* MALFORMED_FUNCTION_CALL */:
+      return "error";
+    default:
+      return "unknown";
+  }
+}
+function responseNodeToContent(node) {
+  if (node.type === 5 /* TOOL_USE */ && node.tool_use) {
+    return {
+      type: "tool-call",
+      toolCallId: node.tool_use.tool_use_id,
+      toolName: node.tool_use.tool_name,
+      input: node.tool_use.input_json || "{}"
+    };
+  }
+  if (node.type === 8 /* THINKING */ && node.thinking) {
+    const text = node.thinking.content || node.thinking.summary || "";
+    if (text) {
+      return { type: "reasoning", text };
+    }
+  }
+  return null;
+}
+class AugmentLanguageModel {
+  specificationVersion = "v2";
+  provider = "augment";
+  modelId;
+  apiKey;
+  apiUrl;
+  sessionId;
+  debug;
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.apiKey = config.apiKey;
+    this.apiUrl = config.apiUrl.endsWith("/") ? config.apiUrl.slice(0, -1) : config.apiUrl;
+    this.sessionId = uuidv4();
+    this.debug = config.debug ?? false;
+  }
+  log(message) {
+    if (this.debug) {
+      console.log(`[Augment] ${message}`);
+    }
+  }
+  getHeaders(requestId) {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      "X-Request-Session-Id": this.sessionId,
+      "X-Request-Id": requestId,
+      "conversation-id": this.sessionId,
+      "X-Mode": "sdk",
+      "User-Agent": "auggie-sdk/1.0.0 (typescript)"
+    };
+  }
+  buildPayload(options) {
+    const { message, nodes, chatHistory, toolDefinitions } = buildChatRequest(
+      options.prompt,
+      options.tools
+    );
+    return {
+      mode: "CLI_AGENT",
+      model: this.modelId,
+      message,
+      nodes,
+      chat_history: chatHistory,
+      conversation_id: this.sessionId,
+      tool_definitions: toolDefinitions.length > 0 ? toolDefinitions : void 0
+    };
+  }
+  doGenerate(options) {
+    const run = async () => {
+      const requestId = uuidv4();
+      const url = `${this.apiUrl}/chat-stream`;
+      const payload = this.buildPayload(options);
+      this.log(`POST ${url}`);
+      if (this.debug && payload.tool_definitions) {
+        this.log(`Tools: ${payload.tool_definitions.map((t) => t.name).join(", ")}`);
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.getHeaders(requestId),
+        body: JSON.stringify(payload),
+        signal: options.abortSignal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Augment API error: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body is null");
+      }
+      const { content, usage, finishReason } = await this.parseStreamResponse(response.body);
+      return {
+        content,
+        finishReason,
+        usage,
+        warnings: []
+      };
+    };
+    return run();
+  }
+  /**
+   * Parse streaming response and collect content, usage, and finish reason
+   */
+  async parseStreamResponse(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let textBuffer = "";
+    let accumulatedText = "";
+    const content = [];
+    let usage = { inputTokens: void 0, outputTokens: void 0, totalTokens: void 0 };
+    let stopReason;
+    const toolCallsEmitted = /* @__PURE__ */ new Set();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        textBuffer += decoder.decode(value, { stream: true });
+        while (textBuffer.includes("\n")) {
+          const newLineIndex = textBuffer.indexOf("\n");
+          const line = textBuffer.substring(0, newLineIndex);
+          textBuffer = textBuffer.substring(newLineIndex + 1);
+          const trimmed = line.trim();
+          if (trimmed) {
+            try {
+              const chunk = JSON.parse(trimmed);
+              if (chunk.text) {
+                accumulatedText += chunk.text;
+              }
+              if (chunk.nodes) {
+                for (const node of chunk.nodes) {
+                  if (node.type === 5 /* TOOL_USE */ && node.tool_use) {
+                    if (!toolCallsEmitted.has(node.tool_use.tool_use_id)) {
+                      toolCallsEmitted.add(node.tool_use.tool_use_id);
+                      const toolContent = responseNodeToContent(node);
+                      if (toolContent) {
+                        content.push(toolContent);
+                      }
+                    }
+                  } else if (node.type === 8 /* THINKING */) {
+                    const thinkingContent = responseNodeToContent(node);
+                    if (thinkingContent) {
+                      content.push(thinkingContent);
+                    }
+                  } else if (node.type === 10 /* TOKEN_USAGE */ && node.token_usage) {
+                    usage = {
+                      inputTokens: node.token_usage.input_tokens,
+                      outputTokens: node.token_usage.output_tokens,
+                      totalTokens: (node.token_usage.input_tokens ?? 0) + (node.token_usage.output_tokens ?? 0) || void 0
+                    };
+                  }
+                }
+              }
+              if (chunk.stop_reason !== void 0) {
+                stopReason = chunk.stop_reason;
+              }
+            } catch {
+              if (this.debug) this.log(`JSON parse failed for line: ${trimmed}`);
+            }
+          }
+        }
+      }
+      const finalChunk = decoder.decode();
+      if (finalChunk) textBuffer += finalChunk;
+      if (textBuffer.trim()) {
+        try {
+          const chunk = JSON.parse(textBuffer.trim());
+          if (chunk.text) accumulatedText += chunk.text;
+          if (chunk.stop_reason !== void 0) stopReason = chunk.stop_reason;
+        } catch {
+          if (this.debug) this.log(`JSON parse failed for remaining: ${textBuffer.trim()}`);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (accumulatedText) {
+      content.unshift({ type: "text", text: accumulatedText });
+    }
+    return {
+      content,
+      usage,
+      finishReason: stopReasonToFinishReason(stopReason)
+    };
+  }
+  doStream(options) {
+    const requestId = uuidv4();
+    const url = `${this.apiUrl}/chat-stream`;
+    const payload = this.buildPayload(options);
+    this.log(`POST ${url} (streaming)`);
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: this.getHeaders(requestId),
+            body: JSON.stringify(payload),
+            signal: options.abortSignal
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Augment API error: ${response.status} ${response.statusText} - ${errorText}`);
+          }
+          if (!response.body) {
+            throw new Error("Response body is null");
+          }
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          let textBuffer = "";
+          let textStarted = false;
+          const textId = uuidv4();
+          let stopReason;
+          const toolCallsEmitted = /* @__PURE__ */ new Set();
+          let usage = { inputTokens: void 0, outputTokens: void 0, totalTokens: void 0 };
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            textBuffer += decoder.decode(value, { stream: true });
+            while (textBuffer.includes("\n")) {
+              const newLineIndex = textBuffer.indexOf("\n");
+              const line = textBuffer.substring(0, newLineIndex);
+              textBuffer = textBuffer.substring(newLineIndex + 1);
+              const trimmed = line.trim();
+              if (trimmed) {
+                try {
+                  const chunk = JSON.parse(trimmed);
+                  if (chunk.text) {
+                    if (!textStarted) {
+                      controller.enqueue({ type: "text-start", id: textId });
+                      textStarted = true;
+                    }
+                    controller.enqueue({ type: "text-delta", id: textId, delta: chunk.text });
+                  }
+                  if (chunk.nodes) {
+                    for (const node of chunk.nodes) {
+                      if (node.type === 5 /* TOOL_USE */ && node.tool_use) {
+                        if (!toolCallsEmitted.has(node.tool_use.tool_use_id)) {
+                          toolCallsEmitted.add(node.tool_use.tool_use_id);
+                          const inputJson = node.tool_use.input_json || "{}";
+                          controller.enqueue({
+                            type: "tool-input-start",
+                            id: node.tool_use.tool_use_id,
+                            toolName: node.tool_use.tool_name
+                          });
+                          controller.enqueue({
+                            type: "tool-input-delta",
+                            id: node.tool_use.tool_use_id,
+                            delta: inputJson
+                          });
+                          controller.enqueue({
+                            type: "tool-input-end",
+                            id: node.tool_use.tool_use_id
+                          });
+                          controller.enqueue({
+                            type: "tool-call",
+                            toolCallId: node.tool_use.tool_use_id,
+                            toolName: node.tool_use.tool_name,
+                            input: inputJson
+                          });
+                        }
+                      } else if (node.type === 8 /* THINKING */ && node.thinking) {
+                        const text = node.thinking.content || node.thinking.summary || "";
+                        if (text) {
+                          const reasoningId = uuidv4();
+                          controller.enqueue({ type: "reasoning-start", id: reasoningId });
+                          controller.enqueue({ type: "reasoning-delta", id: reasoningId, delta: text });
+                          controller.enqueue({ type: "reasoning-end", id: reasoningId });
+                        }
+                      } else if (node.type === 10 /* TOKEN_USAGE */ && node.token_usage) {
+                        usage = {
+                          inputTokens: node.token_usage.input_tokens,
+                          outputTokens: node.token_usage.output_tokens,
+                          totalTokens: (node.token_usage.input_tokens ?? 0) + (node.token_usage.output_tokens ?? 0) || void 0
+                        };
+                      }
+                    }
+                  }
+                  if (chunk.stop_reason !== void 0) {
+                    stopReason = chunk.stop_reason;
+                  }
+                } catch {
+                  if (this.debug) this.log(`JSON parse failed: ${trimmed}`);
+                }
+              }
+            }
+          }
+          if (textStarted) {
+            controller.enqueue({ type: "text-end", id: textId });
+          }
+          controller.enqueue({
+            type: "finish",
+            usage,
+            finishReason: stopReasonToFinishReason(stopReason)
+          });
+          controller.close();
+        } catch (error) {
+          controller.enqueue({ type: "error", error });
+          controller.error(error);
+        }
+      }
+    });
+    return Promise.resolve({ stream });
+  }
+  supportsImageUrls = false;
+  supportsStructuredOutputs = false;
+  supportedUrls = {};
+}
+export {
+  AugmentLanguageModel,
+  resolveAugmentCredentials
+};

package/dist/auggie/sdk-acp-client.d.ts

@@ -39,6 +39,33 @@ type AuggieOptions = {
      * ```
      */
     excludedTools?: ToolIdentifier[];
+    /**
+     * Additional command-line arguments to pass to the Auggie CLI process.
+     * These arguments are appended to the CLI command when spawning the process.
+     *
+     * Use this option to pass custom or advanced CLI flags that are not
+     * directly exposed through other AuggieOptions properties.
+     *
+     * Arguments can be provided as:
+     * - Flag-only arguments: `"--verbose"`
+     * - Flag with value (separate strings): `"--timeout", "30"`
+     * - Flag with value (single string): `"--timeout=30"`
+     *
+     * @example
+     * ```typescript
+     * // Pass a single flag
+     * cliArgs: ["--verbose"]
+     *
+     * // Pass multiple arguments with values
+     * cliArgs: ["--timeout", "30", "--retries", "3"]
+     *
+     * // Pass flags with equals-style values
+     * cliArgs: ["--timeout=30", "--retries=3"]
+     * ```
+     *
+     * @default []
+     */
+    cliArgs?: string[];
 };
 /**
  * ACP Client for connecting to Auggie as an ACP server
@@ -65,6 +92,7 @@ declare class Auggie {
     private readonly apiUrl;
     private readonly rules;
     private readonly excludedTools;
+    private readonly cliArgs;
     private constructor();
     /**
      * Create and initialize a new Auggie instance

package/dist/auggie/sdk-acp-client.js

@@ -24,6 +24,7 @@ class Auggie {
   apiUrl;
   rules;
   excludedTools;
+  cliArgs;
   constructor({
     auggiePath = "auggie",
     workspaceRoot,
@@ -32,7 +33,8 @@ class Auggie {
     apiKey,
     apiUrl = process.env.AUGMENT_API_URL || "https://api.augmentcode.com",
     rules,
-    excludedTools
+    excludedTools,
+    cliArgs = []
   } = {}) {
     this.auggiePath = auggiePath;
     this.workspaceRoot = workspaceRoot;
@@ -42,6 +44,7 @@ class Auggie {
     this.apiUrl = apiUrl;
     this.rules = rules;
     this.excludedTools = excludedTools;
+    this.cliArgs = cliArgs;
   }
   /**
    * Create and initialize a new Auggie instance
@@ -81,6 +84,9 @@ class Auggie {
         args.push("--remove-tool", tool);
       }
     }
+    if (this.cliArgs.length > 0) {
+      args.push(...this.cliArgs);
+    }
     const pathParts = this.auggiePath.trim().split(Auggie.PATH_SPLIT_REGEX);
     if (pathParts.length === 0 || !pathParts[0]) {
       throw new Error("Invalid auggiePath: cannot be empty");

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { Auggie, PredefinedToolType, ToolIdentifier } from './auggie/sdk-acp-client.js';
+export { AugmentCredentials, AugmentLanguageModel, AugmentLanguageModelConfig, resolveAugmentCredentials } from './auggie/ai-sdk-provider.js';
 export { DirectContext } from './context/direct-context.js';
 export { FileSystemContext } from './context/filesystem-context.js';
 export { APIError } from './context/internal/api-client.js';
@@ -6,3 +7,5 @@ export { BlobTooLargeError } from './context/internal/blob-name-calculator.js';
 export { AddToIndexOptions, BlobEntry, BlobInfo, Blobs, DirectContextOptions, DirectContextState, ExportOptions, File, FileSystemContextOptions, FullContextState, IndexingProgress, IndexingResult, SearchOnlyContextState } from './context/types.js';
 import '@agentclientprotocol/sdk';
 import 'ai';
+import '@ai-sdk/provider';
+import './context/internal/credentials.js';

package/dist/index.js

@@ -1,6 +1,10 @@
 import {
   Auggie
 } from "./auggie/sdk-acp-client.js";
+import {
+  AugmentLanguageModel,
+  resolveAugmentCredentials
+} from "./auggie/ai-sdk-provider.js";
 import { DirectContext } from "./context/direct-context.js";
 import { FileSystemContext } from "./context/filesystem-context.js";
 import { APIError } from "./context/internal/api-client.js";
@@ -8,7 +12,9 @@ import { BlobTooLargeError } from "./context/internal/blob-name-calculator.js";
 export {
   APIError,
   Auggie,
+  AugmentLanguageModel,
   BlobTooLargeError,
   DirectContext,
-  FileSystemContext
+  FileSystemContext,
+  resolveAugmentCredentials
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augmentcode/auggie-sdk",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "TypeScript SDK for Auggie",
   "type": "module",
   "main": "./dist/index.js",
@@ -35,10 +35,11 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.5.1",
+    "@ai-sdk/provider": "^3.0.3",
     "@mastra/mcp": "^0.14.1",
     "ai": "^5.0.86",
     "async-mutex": "^0.5.0",
-    "zod": "^4.1.12",
-    "uuid": "^11.1.0"
+    "uuid": "^11.1.0",
+    "zod": "^4.1.12"
   }
 }