@coder/ai-sdk-agent 0.1.0 → 0.2.0

package/dist/index.js

@@ -42,7 +42,70 @@ var CoderChatError = class extends CoderAgentError {
   }
 };
 
+// src/files.ts
+function isBlob(v) {
+  return typeof Blob !== "undefined" && v instanceof Blob;
+}
+function isReadableStream(v) {
+  return typeof ReadableStream !== "undefined" && v instanceof ReadableStream;
+}
+function resolveFileContent(content, opts) {
+  let mediaType = opts?.mediaType;
+  let name = opts?.name;
+  let body;
+  let size;
+  if (isBlob(content)) {
+    body = content;
+    size = content.size;
+    if (!mediaType && content.type) mediaType = content.type;
+    const maybeName = content.name;
+    if (!name && typeof maybeName === "string") name = maybeName;
+  } else if (isReadableStream(content)) {
+    body = content;
+    size = void 0;
+  } else if (content instanceof Uint8Array || content instanceof ArrayBuffer) {
+    size = content.byteLength;
+    body = new Blob([content]);
+  } else {
+    throw new CoderAgentError(
+      "Unsupported file content: expected a Blob/File, ReadableStream, Uint8Array, or ArrayBuffer."
+    );
+  }
+  if (!mediaType) {
+    throw new CoderAgentError(
+      "Could not determine the file's media type. Pass `mediaType`, or provide a Blob/File that carries its own `type`."
+    );
+  }
+  return { body, mediaType, name, size };
+}
+function base64ToBytes(b64) {
+  if (typeof Buffer !== "undefined") return Buffer.from(b64, "base64");
+  const bin = atob(b64);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+function dataContentToFileContent(data) {
+  if (data instanceof Uint8Array) return data;
+  if (typeof data === "string") return base64ToBytes(data);
+  throw new CoderAgentError(
+    "File parts referencing a URL are not supported; provide the file bytes instead."
+  );
+}
+
 // src/coder/types.ts
+var CHAT_ATTACHMENT_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "application/json",
+  "application/pdf",
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "text/csv",
+  "text/markdown",
+  "text/plain"
+]);
+var MAX_CHAT_FILE_SIZE_BYTES = 10 * 1024 * 1024;
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "waiting",
   "completed",
@@ -162,24 +225,23 @@ var CoderChatClient = class {
     this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.#webSocketFactory = options.webSocketFactory;
   }
-  async #request(method, path, body, signal) {
-    const headers = { "Coder-Session-Token": this.#token };
-    if (body !== void 0) headers["Content-Type"] = "application/json";
-    const res = await this.#fetch(`${this.baseUrl}${path}`, {
-      method,
-      headers,
-      body: body === void 0 ? void 0 : JSON.stringify(body),
-      signal
-    });
-    const text = await res.text();
-    let parsed;
-    try {
-      parsed = text.length > 0 ? JSON.parse(text) : void 0;
-    } catch {
-      parsed = void 0;
+  /**
+   * Issue a request and return the raw `Response` on success (body unread). On a
+   * non-2xx status the body is consumed to build a {@link CoderApiError}. Shared
+   * by JSON requests and the raw upload/download endpoints.
+   */
+  async #send(method, path, opts) {
+    const headers = {
+      "Coder-Session-Token": this.#token,
+      ...opts?.headers
+    };
+    const init = { method, headers, body: opts?.body, signal: opts?.signal };
+    if (typeof ReadableStream !== "undefined" && opts?.body instanceof ReadableStream) {
+      init.duplex = "half";
     }
+    const res = await this.#fetch(`${this.baseUrl}${path}`, init);
     if (!res.ok) {
-      const errObj = parsed ?? {};
+      const errObj = await this.#json(res) ?? {};
       throw new CoderApiError({
         status: res.status,
         method,
@@ -188,7 +250,25 @@ var CoderChatClient = class {
         detail: errObj.detail
       });
     }
-    return parsed;
+    return res;
+  }
+  /** Read a response body as JSON, tolerating an unreadable/empty/malformed body (→ undefined). */
+  async #json(res) {
+    const text = await res.text().catch(() => "");
+    if (text.length === 0) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return void 0;
+    }
+  }
+  async #request(method, path, body, signal) {
+    const res = await this.#send(method, path, {
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      headers: body === void 0 ? void 0 : { "Content-Type": "application/json" },
+      signal
+    });
+    return await this.#json(res);
   }
   // --- REST -----------------------------------------------------------------
   listModelConfigs(signal) {
@@ -239,6 +319,66 @@ var CoderChatClient = class {
   archiveChat(chatId, signal) {
     return this.updateChat(chatId, { archived: true }, signal);
   }
+  // --- Files ----------------------------------------------------------------
+  /**
+   * Upload a file as a durable chat attachment, returning its id (referenced
+   * from message content via a `file` input part). The server enforces a narrow
+   * media-type allowlist and a 10 MiB cap; both are checked client-side first so
+   * unsupported files fail fast with a clear error instead of an opaque 4xx.
+   *
+   * The body is sent raw (not multipart): `Content-Type` carries the media type
+   * and `Content-Disposition` the filename, mirroring `codersdk`.
+   */
+  async uploadChatFile(organizationId, file, signal) {
+    const resolved = resolveFileContent(file.content, {
+      mediaType: file.mediaType,
+      name: file.name
+    });
+    const mediaType = (resolved.mediaType.split(";")[0] ?? resolved.mediaType).trim().toLowerCase();
+    if (!CHAT_ATTACHMENT_MEDIA_TYPES.has(mediaType)) {
+      throw new CoderAgentError(
+        `Media type "${mediaType}" is not allowed for chat attachments (allowed: ${[...CHAT_ATTACHMENT_MEDIA_TYPES].join(", ")}). Write other file types to a workspace instead.`
+      );
+    }
+    if (resolved.size !== void 0 && resolved.size > MAX_CHAT_FILE_SIZE_BYTES) {
+      throw new CoderAgentError(
+        `File is ${resolved.size} bytes, over the ${MAX_CHAT_FILE_SIZE_BYTES}-byte (10 MiB) chat attachment limit. Write large files to a workspace instead.`
+      );
+    }
+    const headers = { "Content-Type": mediaType };
+    if (resolved.name) {
+      const ascii = resolved.name.replace(/[^\x20-\x7e]/g, "_").replace(/(["\\])/g, "\\$1");
+      const utf8 = encodeURIComponent(resolved.name).replace(
+        /['()*]/g,
+        (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`
+      );
+      headers["Content-Disposition"] = `attachment; filename="${ascii}"; filename*=UTF-8''${utf8}`;
+    }
+    const res = await this.#send(
+      "POST",
+      `${API_PREFIX}/files?organization=${encodeURIComponent(organizationId)}`,
+      { body: resolved.body, headers, signal }
+    );
+    const parsed = await this.#json(res);
+    if (!parsed?.id) {
+      throw new CoderApiError({
+        status: res.status,
+        method: "POST",
+        path: `${API_PREFIX}/files`,
+        message: "upload succeeded but the response contained no file id"
+      });
+    }
+    return { id: parsed.id, mediaType, name: resolved.name };
+  }
+  /** Download a chat file's bytes and media type by id. */
+  async getChatFile(fileId, signal) {
+    const res = await this.#send("GET", `${API_PREFIX}/files/${fileId}`, { signal });
+    const buf = await res.arrayBuffer();
+    return {
+      bytes: new Uint8Array(buf),
+      mediaType: res.headers.get("Content-Type") ?? "application/octet-stream"
+    };
+  }
   // --- Streaming ------------------------------------------------------------
   streamEvents(chatId, opts) {
     return streamChatEvents({
@@ -283,6 +423,7 @@ var CoderChatClient = class {
 };
 
 // src/model/prompt.ts
+var CODER_PROVIDER_OPTIONS = "coder";
 function extractSystemPrompt(prompt) {
   const parts = prompt.filter(
     (m) => m.role === "system"
@@ -291,14 +432,28 @@ function extractSystemPrompt(prompt) {
   const joined = parts.map((m) => m.content).join("\n\n").trim();
   return joined.length > 0 ? joined : void 0;
 }
-function userContentToInputParts(message) {
-  const out = [];
-  for (const part of message.content) {
-    if (part.type === "text" && part.text.length > 0) {
-      out.push({ type: "text", text: part.text });
-    }
-  }
-  return out;
+function coderFileId(providerOptions) {
+  const ns = providerOptions?.[CODER_PROVIDER_OPTIONS];
+  return typeof ns?.fileId === "string" && ns.fileId.length > 0 ? ns.fileId : void 0;
+}
+async function userContentToInputParts(content, uploadFile) {
+  const parts = await Promise.all(
+    content.map(async (part) => {
+      if (part.type === "text") {
+        return part.text.length > 0 ? { type: "text", text: part.text } : null;
+      }
+      if (part.type === "file") {
+        const fileId = coderFileId(part.providerOptions) ?? await uploadFile({
+          data: part.data,
+          mediaType: part.mediaType,
+          filename: part.filename
+        });
+        return { type: "file", file_id: fileId };
+      }
+      return null;
+    })
+  );
+  return parts.filter((p) => p !== null);
 }
 function toolResultOutputToChatd(output) {
   switch (output.type) {
@@ -336,7 +491,7 @@ function classifyTurnAction(prompt) {
     return { kind: "resume", toolResults };
   }
   if (last.role === "user") {
-    return { kind: "new-turn", content: userContentToInputParts(last) };
+    return { kind: "new-turn", content: last.content };
   }
   return { kind: "noop" };
 }
@@ -678,6 +833,23 @@ var CoderLanguageModel = class {
     this.#modelResolved = true;
     return this.#resolvedModelConfigId;
   }
+  /**
+   * Resolve a user message's content to chatd input parts, uploading any file
+   * parts to chat-file storage (the upload endpoint needs only the organization
+   * id, so this runs before the chat exists). Pre-uploaded files carried via
+   * `providerOptions.coder.fileId` are referenced without re-uploading.
+   */
+  #buildContent(content, signal) {
+    const uploadFile = async (f) => {
+      const uploaded = await this.#config.client.uploadChatFile(
+        this.#config.organizationId,
+        { content: dataContentToFileContent(f.data), mediaType: f.mediaType, name: f.filename },
+        signal
+      );
+      return uploaded.id;
+    };
+    return userContentToInputParts(content, uploadFile);
+  }
   async *#runTurn(options) {
     if (this.#inFlight) {
       throw new CoderAgentError(
@@ -685,23 +857,62 @@ var CoderLanguageModel = class {
       );
     }
     this.#inFlight = true;
+    const externalSignal = options.abortSignal;
+    const timeoutMs = this.#config.requestTimeoutMs;
+    const timeoutSignal = timeoutMs !== void 0 && timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : void 0;
+    const sources = [externalSignal, timeoutSignal].filter(
+      (s) => s !== void 0
+    );
+    const signal = sources.length > 0 ? AbortSignal.any(sources) : void 0;
+    const translator = new TurnTranslator({ dynamicToolNames: dynamicToolNames(options.tools) });
+    let interruptSent = false;
+    const interrupt = () => {
+      const id = this.#chatId;
+      if (interruptSent || !id) return;
+      interruptSent = true;
+      void this.#config.client.interruptChat(id).catch(() => {
+      });
+    };
+    signal?.addEventListener("abort", interrupt, { once: true });
+    const throwIfAborted = () => {
+      if (timeoutSignal?.aborted) {
+        throw new CoderChatError({
+          message: `Coder Agent turn exceeded its ${timeoutMs}ms requestTimeoutMs budget.`,
+          kind: "timeout",
+          retryable: true
+        });
+      }
+      if (signal?.aborted) {
+        throw externalSignal?.reason ?? new DOMException("The operation was aborted.", "AbortError");
+      }
+    };
     try {
-      const { prompt, abortSignal: signal } = options;
-      yield { type: "stream-start", warnings: [] };
+      const { prompt } = options;
+      const warnings = [];
+      if (options.responseFormat?.type === "json") {
+        warnings.push({
+          type: "unsupported",
+          feature: "responseFormat",
+          details: "Coder Agents does not enforce a JSON schema server-side, so structured output is best-effort (not schema-constrained). For reliable structured output, use @coder/ai-sdk-provider (createCoder) with generateObject / Output.object."
+        });
+      }
+      yield { type: "stream-start", warnings };
       const action = classifyTurnAction(prompt);
       if (action.kind === "noop") {
         throw new CoderAgentError(
           "CoderAgent received a prompt with no user message or tool results to act on."
         );
       }
-      const translator = new TurnTranslator({ dynamicToolNames: dynamicToolNames(options.tools) });
       let afterId;
       if (action.kind === "new-turn") {
-        const modelConfigId = await this.#resolveModelConfigId(signal);
+        const [modelConfigId, content] = await Promise.all([
+          this.#resolveModelConfigId(signal),
+          this.#buildContent(action.content, signal)
+        ]);
         if (!this.#chatId) {
           const req = {
             organization_id: this.#config.organizationId,
-            content: action.content,
+            content,
             client_type: "api"
           };
           const system = extractSystemPrompt(prompt);
@@ -719,7 +930,7 @@ var CoderLanguageModel = class {
           const resp = await this.#config.client.createChatMessage(
             this.#chatId,
             {
-              content: action.content,
+              content,
               ...modelConfigId ? { model_config_id: modelConfigId } : {}
             },
             signal
@@ -740,27 +951,51 @@ var CoderLanguageModel = class {
       }
       const chatId = this.#chatId;
       let sinceRequiresAction = 0;
-      for await (const ev of this.#config.client.streamEvents(chatId, { afterId, signal })) {
-        for (const part of translator.ingest(ev)) yield part;
-        const status = translator.terminalStatus;
-        if (status) {
-          if (status !== "requires_action") break;
-          if (translator.clientToolCallSeen) break;
-          if (++sinceRequiresAction > 200) break;
+      try {
+        for await (const ev of this.#config.client.streamEvents(chatId, { afterId, signal })) {
+          for (const part of translator.ingest(ev)) yield part;
+          const status = translator.terminalStatus;
+          if (status) {
+            if (status !== "requires_action") break;
+            if (translator.clientToolCallSeen) break;
+            if (++sinceRequiresAction > 200) break;
+          }
         }
+      } catch (err) {
+        throwIfAborted();
+        if (err instanceof CoderAgentError && !(err instanceof CoderApiError) && !(err instanceof CoderChatError)) {
+          throw new CoderChatError({
+            message: `Coder chat stream failed mid-turn: ${err.message}`,
+            kind: "stream_closed",
+            retryable: true
+          });
+        }
+        throw err;
       }
-      if (signal?.aborted && !translator.terminalStatus) {
-        throw signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+      throwIfAborted();
+      if (!translator.terminalStatus && !translator.error) {
+        throw new CoderChatError({
+          message: "Coder chat stream ended before the turn settled (connection closed or the server ended the stream without a terminal status).",
+          kind: "stream_closed",
+          retryable: true
+        });
       }
       for (const part of translator.finish()) yield part;
+    } catch (err) {
+      throwIfAborted();
+      throw err;
+    } finally {
       if (translator.maxMessageId > this.#lastSeenMessageId)
         this.#lastSeenMessageId = translator.maxMessageId;
-    } finally {
+      signal?.removeEventListener("abort", interrupt);
+      if (!translator.terminalStatus) interrupt();
       this.#inFlight = false;
     }
   }
   async doStream(options) {
-    const gen = this.#runTurn(options);
+    const cancelController = new AbortController();
+    const abortSignal = options.abortSignal ? AbortSignal.any([options.abortSignal, cancelController.signal]) : cancelController.signal;
+    const gen = this.#runTurn({ ...options, abortSignal });
     const stream = new ReadableStream({
       async pull(controller) {
         try {
@@ -768,11 +1003,14 @@ var CoderLanguageModel = class {
           if (done) controller.close();
           else controller.enqueue(value);
         } catch (err) {
-          controller.error(err);
+          if (cancelController.signal.aborted) controller.close();
+          else controller.error(err);
         }
       },
       async cancel() {
-        await gen.return();
+        cancelController.abort();
+        await gen.return().catch(() => {
+        });
       }
     });
     return { stream };
@@ -837,12 +1075,27 @@ var CoderLanguageModel = class {
 };
 
 // src/agent/coder-agent.ts
+function makeChatAttachment(file) {
+  return {
+    ...file,
+    toFilePart: () => ({
+      type: "file",
+      // Bytes are unused: the reference travels in providerOptions.coder.fileId.
+      data: "",
+      mediaType: file.mediaType,
+      ...file.name ? { filename: file.name } : {},
+      providerOptions: { [CODER_PROVIDER_OPTIONS]: { fileId: file.id } }
+    })
+  };
+}
 var DEFAULT_STOP = stepCountIs(64);
 var CoderAgent = class {
   version = "agent-v1";
   #client;
   #model;
   #inner;
+  #organizationId;
+  #workspaceFiles;
   constructor(settings) {
     if (settings.client) {
       this.#client = settings.client;
@@ -858,6 +1111,13 @@ var CoderAgent = class {
         "CoderAgent requires either `client` or both `baseUrl` and `token`."
       );
     }
+    this.#organizationId = settings.organizationId;
+    this.#workspaceFiles = settings.workspaceFiles;
+    if (settings.workspaceFiles && settings.workspaceId && settings.workspaceFiles.workspaceId !== settings.workspaceId) {
+      throw new CoderAgentError(
+        `workspaceFiles.workspaceId (${settings.workspaceFiles.workspaceId}) does not match the agent's workspaceId (${settings.workspaceId}); the chat's tools would not see uploaded files.`
+      );
+    }
     this.#model = new CoderLanguageModel({
       client: this.#client,
       organizationId: settings.organizationId,
@@ -865,7 +1125,8 @@ var CoderAgent = class {
       workspaceId: settings.workspaceId,
       mcpServerIds: settings.mcpServerIds,
       planMode: settings.planMode,
-      chatId: settings.chatId
+      chatId: settings.chatId,
+      requestTimeoutMs: settings.requestTimeoutMs
     });
     this.#inner = new ToolLoopAgent({
       model: this.#model,
@@ -898,6 +1159,14 @@ var CoderAgent = class {
     return this.#inner.stream(options);
   }
   // --- session helpers ------------------------------------------------------
+  /**
+   * List the model configs available on the deployment. Use this to discover
+   * valid values for the `model` hint instead of guessing ids — match on
+   * `id`, `provider`/`model`, or `display_name`.
+   */
+  listModels(signal) {
+    return this.#client.listModelConfigs(signal);
+  }
   /** Start a fresh chatd chat on the next turn. */
   resetSession() {
     this.#model.resetSession();
@@ -912,19 +1181,89 @@ var CoderAgent = class {
     const id = this.#model.chatId;
     if (id) await this.#client.archiveChat(id);
   }
+  /**
+   * Clean up the chat when the agent leaves an `await using` scope, so cleanup
+   * rides scope exit instead of a separate call you have to remember in a
+   * `finally`. Interrupts any in-flight server run, then archives the chat.
+   * Best-effort: disposal errors are swallowed so they can't mask the scope's
+   * own error.
+   *
+   * @example
+   * ```ts
+   * await using agent = new CoderAgent({ ... });
+   * const { text } = await agent.generate({ prompt: "…" });
+   * // agent.interrupt() + agent.archive() run automatically here.
+   * ```
+   */
+  async [Symbol.asyncDispose]() {
+    try {
+      await this.interrupt();
+    } catch {
+    }
+    try {
+      await this.archive();
+    } catch {
+    }
+  }
+  // --- files ----------------------------------------------------------------
+  /**
+   * Upload a file as a chat attachment — content for the model to *read* (a PDF,
+   * image, CSV, …). Returns a handle you can reference from a later turn via
+   * {@link ChatAttachment.toFilePart} (no re-upload). Validated against the chat
+   * allowlist and 10 MiB cap up front.
+   *
+   * You usually don't need this: a native AI SDK `file` part dropped into a
+   * message's `content` is uploaded transparently. Reach for `attach()` to
+   * pre-upload, to reuse one file across turns, or to validate before sending.
+   *
+   * For large or non-allowlisted files (zips, datasets, binaries) — material for
+   * the agent to *operate on* — use {@link CoderAgent.uploadToWorkspace}.
+   */
+  async attach(file, signal) {
+    const uploaded = await this.#client.uploadChatFile(this.#organizationId, file, signal);
+    return makeChatAttachment(uploaded);
+  }
+  /**
+   * Write a file onto the bound workspace's filesystem for the agent to operate
+   * on (extract, build, read with its tools). Requires a {@link WorkspaceFileStore}
+   * via the `workspaceFiles` setting. The file is written as-is — no unpacking;
+   * instruct the agent to `unzip`/`tar -x`, or extract over your own connection.
+   *
+   * The chat should be bound to the same workspace (`workspaceId`) so the agent's
+   * server-side tools can see the file.
+   */
+  async uploadToWorkspace(file) {
+    if (!this.#workspaceFiles) {
+      throw new CoderAgentError(
+        "uploadToWorkspace requires a `workspaceFiles` adapter. Construct the agent with `workspaceFiles` (e.g. backed by a @coder/ai-sdk-eve-sandbox session) to enable it."
+      );
+    }
+    const { path } = await this.#workspaceFiles.write({
+      content: file.content,
+      path: file.path,
+      signal: file.signal
+    });
+    return { workspaceId: this.#workspaceFiles.workspaceId, path };
+  }
 };
 export {
+  CHAT_ATTACHMENT_MEDIA_TYPES,
+  CODER_PROVIDER_OPTIONS,
   CoderAgent,
   CoderAgentError,
   CoderApiError,
   CoderChatClient,
   CoderChatError,
   CoderLanguageModel,
+  MAX_CHAT_FILE_SIZE_BYTES,
   TurnTranslator,
   classifyTurnAction,
+  dataContentToFileContent,
   dynamicToolNames,
   extractSystemPrompt,
+  resolveFileContent,
   streamChatEvents,
-  toolsToDynamicTools
+  toolsToDynamicTools,
+  userContentToInputParts
 };
 //# sourceMappingURL=index.js.map