@archships/dim-agent-sdk 0.0.3 → 0.0.5

package/dist/src/providers/openai/index.js

@@ -0,0 +1,499 @@
+// src/providers/core/create-provider-factory.ts
+function createProviderFactory(definition) {
+  return function createConfiguredAdapter(options) {
+    const provider = options.provider ?? definition.defaultProvider;
+    const defaultModel = {
+      provider,
+      modelId: options.defaultModel
+    };
+    return {
+      provider,
+      defaultModel,
+      async* stream(request) {
+        const requestId = request.requestId ?? crypto.randomUUID();
+        const model = request.model ?? defaultModel;
+        yield { type: "response_start", requestId, model };
+        const context = {
+          options,
+          provider,
+          defaultModel,
+          request: {
+            ...request,
+            model
+          }
+        };
+        let result;
+        try {
+          result = await definition.driver.generate(context);
+        } catch (error) {
+          const payload = definition.driver.normalizeError ? await definition.driver.normalizeError(error, context) : createFallbackErrorPayload(provider, error);
+          yield {
+            type: "error",
+            requestId,
+            error: payload,
+            terminal: true
+          };
+          return;
+        }
+        for (const segment of result.content) {
+          if (segment.type === "text") {
+            if (segment.text.length > 0)
+              yield { type: "text_delta", requestId, delta: segment.text };
+            continue;
+          }
+          if (segment.type === "thinking") {
+            if (segment.text.length > 0)
+              yield { type: "thinking_delta", requestId, delta: segment.text };
+            continue;
+          }
+          yield {
+            type: "tool_call_start",
+            requestId,
+            callId: segment.callId,
+            toolName: segment.toolName
+          };
+          yield {
+            type: "tool_call_args_delta",
+            requestId,
+            callId: segment.callId,
+            delta: segment.argsText
+          };
+          yield {
+            type: "tool_call_end",
+            requestId,
+            callId: segment.callId
+          };
+        }
+        yield {
+          type: "response_end",
+          requestId,
+          stopReason: result.stopReason,
+          usage: result.usage,
+          assistantMetadata: result.assistantMetadata
+        };
+      }
+    };
+  };
+}
+function createFallbackErrorPayload(provider, error) {
+  if (error instanceof Error) {
+    return {
+      code: `${provider}_request_error`,
+      message: error.message
+    };
+  }
+  return {
+    code: `${provider}_request_error`,
+    message: String(error)
+  };
+}
+
+// src/providers/openai/driver.ts
+import { APICallError } from "@ai-sdk/provider";
+import { createOpenAI } from "@ai-sdk/openai";
+
+// src/providers/shared/usage.ts
+function normalizeLanguageModelUsage(raw) {
+  if (!raw)
+    return;
+  const promptTokens = raw.inputTokens.total ?? 0;
+  const completionTokens = raw.outputTokens.total ?? 0;
+  const totalTokens = promptTokens + completionTokens;
+  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0)
+    return;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens
+  };
+}
+function mapLanguageModelFinishReason(reason) {
+  const raw = reason.raw?.toLowerCase();
+  if (raw === "cancelled" || raw === "canceled")
+    return "cancelled";
+  switch (reason.unified) {
+    case "tool-calls":
+      return "tool_call";
+    case "length":
+      return "length";
+    case "content-filter":
+    case "error":
+      return "error";
+    case "other":
+      return raw === "cancelled" || raw === "canceled" ? "cancelled" : "final";
+    case "stop":
+    default:
+      return "final";
+  }
+}
+
+// src/providers/shared/ai-sdk-driver.ts
+async function generateWithAiSdk(input) {
+  const result = await input.model.doGenerate(input.callOptions);
+  const content = [];
+  for (const part of result.content) {
+    if (part.type === "text") {
+      if (part.text.length > 0)
+        content.push({ type: "text", text: part.text });
+      continue;
+    }
+    if (part.type === "reasoning") {
+      if (part.text.length > 0)
+        content.push({ type: "thinking", text: part.text });
+      continue;
+    }
+    if (part.type === "tool-call") {
+      content.push({
+        type: "tool_call",
+        callId: part.toolCallId,
+        toolName: part.toolName,
+        argsText: part.input
+      });
+    }
+  }
+  return {
+    content,
+    stopReason: mapLanguageModelFinishReason(result.finishReason),
+    usage: normalizeLanguageModelUsage(result.usage),
+    assistantMetadata: input.createAssistantMetadata?.(result)
+  };
+}
+
+// src/providers/shared/auth-warning.ts
+var warnedProviders = new Set;
+function warnIfPlaceholderApiKey(input) {
+  if (!input.shouldWarn)
+    return;
+  if (false)
+    ;
+  if (warnedProviders.has(input.provider))
+    return;
+  warnedProviders.add(input.provider);
+  const suffix = input.hint ? ` ${input.hint}` : "";
+  console.warn(`[dim-agent-sdk] ${input.provider} is using a placeholder API key because no apiKey or provider-native auth configuration was provided. ` + `If you rely on external authentication, ensure your custom fetch or provider-native headers add real credentials before the request is sent upstream.${suffix}`);
+}
+
+// src/providers/shared/http-error.ts
+import { STATUS_CODES } from "node:http";
+var MAX_TEXT_CHARS = 4000;
+var MAX_JSON_DEPTH = 4;
+var MAX_JSON_ARRAY_ITEMS = 20;
+var MAX_JSON_OBJECT_KEYS = 40;
+var TRUNCATED_SUFFIX = "...[truncated]";
+function createApiCallErrorPayload(input) {
+  const responseBody = input.error.responseBody ? parseErrorBody(input.error.responseBody) : limitJsonValue(input.error.data);
+  return {
+    code: input.code,
+    message: `${input.provider} request failed${input.error.statusCode ? ` with status ${input.error.statusCode}` : ""}`,
+    status: input.error.statusCode,
+    retryable: input.error.isRetryable,
+    details: {
+      provider: input.provider,
+      endpoint: input.error.url,
+      ...input.error.statusCode ? { statusText: STATUS_CODES[input.error.statusCode] ?? undefined } : {},
+      ...responseBody === undefined ? {} : { responseBody }
+    }
+  };
+}
+function createRequestErrorPayload(input) {
+  if (input.error instanceof Error) {
+    return {
+      code: input.code,
+      message: input.error.message
+    };
+  }
+  return {
+    code: input.code,
+    message: String(input.error)
+  };
+}
+function parseErrorBody(value) {
+  const normalized = value.trim();
+  if (!normalized)
+    return;
+  try {
+    return limitJsonValue(JSON.parse(normalized));
+  } catch {
+    return truncateText(normalized);
+  }
+}
+function limitJsonValue(value, depth = 0) {
+  if (value === undefined)
+    return;
+  if (value === null || typeof value === "boolean" || typeof value === "number")
+    return value;
+  if (typeof value === "string")
+    return truncateText(value);
+  if (Array.isArray(value))
+    return value.slice(0, MAX_JSON_ARRAY_ITEMS).map((item) => limitJsonValue(item, depth + 1));
+  if (typeof value === "object") {
+    if (depth >= MAX_JSON_DEPTH)
+      return truncateText(JSON.stringify(value));
+    const limited = {};
+    for (const [key, child] of Object.entries(value).slice(0, MAX_JSON_OBJECT_KEYS))
+      limited[key] = limitJsonValue(child, depth + 1);
+    return limited;
+  }
+  return truncateText(String(value));
+}
+function truncateText(value) {
+  if (value.length <= MAX_TEXT_CHARS)
+    return value;
+  return `${value.slice(0, MAX_TEXT_CHARS)}${TRUNCATED_SUFFIX}`;
+}
+
+// src/providers/shared/fetch.ts
+function createProviderFetch(input) {
+  const fetchImpl = input.fetch ?? globalThis.fetch;
+  if (!input.stripWhen || !input.stripHeaders || input.stripHeaders.length === 0)
+    return fetchImpl;
+  const headersToStrip = new Set(input.stripHeaders.map((header) => header.toLowerCase()));
+  const wrappedFetch = Object.assign((resource, init) => {
+    if (typeof resource === "string" || resource instanceof URL) {
+      const headers = new Headers(init?.headers);
+      for (const header of headersToStrip)
+        headers.delete(header);
+      return fetchImpl(resource, { ...init, headers });
+    }
+    const request = new Request(resource, init);
+    for (const header of headersToStrip)
+      request.headers.delete(header);
+    return fetchImpl(request);
+  }, {
+    preconnect: typeof fetchImpl.preconnect === "function" ? fetchImpl.preconnect.bind(fetchImpl) : (_url, _options) => {}
+  });
+  return wrappedFetch;
+}
+function hasHeader(headers, target) {
+  if (!headers)
+    return false;
+  const normalized = target.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === normalized);
+}
+
+// src/utils/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+// src/contracts/content-normalize.ts
+function isTextContent(value) {
+  return isRecord(value) && value.type === "text" && typeof value.text === "string" && (value.annotations === undefined || isRecord(value.annotations)) && (value._meta === undefined || isRecord(value._meta));
+}
+function isImageContent(value) {
+  return isRecord(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string" && (value.annotations === undefined || isRecord(value.annotations)) && (value._meta === undefined || isRecord(value._meta));
+}
+function isContentBlock(value) {
+  return isTextContent(value) || isImageContent(value);
+}
+function normalizeContent(input) {
+  if (typeof input === "string") {
+    return [{ type: "text", text: input }];
+  }
+  if (Array.isArray(input)) {
+    const blocks = input.filter((item) => item != null);
+    if (!blocks.every(isContentBlock))
+      throw new TypeError("Content array must contain only text or image blocks");
+    return blocks.map((block) => ({ ...block }));
+  }
+  if (!isContentBlock(input))
+    throw new TypeError("Content must be a string, content block, or content block array");
+  return [{ ...input }];
+}
+function contentToText(content) {
+  return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+
+// src/utils/json.ts
+function isJsonSafeValue(value) {
+  if (value === null)
+    return true;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return true;
+  if (Array.isArray(value))
+    return value.every(isJsonSafeValue);
+  if (isRecord(value))
+    return Object.values(value).every(isJsonSafeValue);
+  return false;
+}
+function assertJsonSafeObject(value, label) {
+  if (!isRecord(value) || !isJsonSafeValue(value))
+    throw new TypeError(`${label} must be a JSON-safe object`);
+}
+function parseJsonObject(value, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${label} must be valid JSON: ${message}`);
+  }
+  if (!isRecord(parsed))
+    throw new Error(`${label} must decode to a JSON object`);
+  return parsed;
+}
+
+// src/providers/shared/prompt.ts
+function mapToolDefinitionsToLanguageModelTools(tools) {
+  if (!tools || tools.length === 0)
+    return;
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  }));
+}
+function messagesToLanguageModelPrompt(messages, options = {}) {
+  const prompt = [];
+  const systemContent = messages.filter((message) => message.role === "system").map((message) => contentToText(message.content)).filter(Boolean).join(`
+
+`);
+  if (systemContent)
+    prompt.push({ role: "system", content: systemContent });
+  for (const message of messages) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "tool") {
+      prompt.push(toolMessageToPrompt(message));
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = [
+        ...options.assistantPrefixParts?.(message) ?? [],
+        ...contentBlocksToPromptParts(message.content),
+        ...toolCallsToPromptParts(message.toolCalls)
+      ];
+      if (content.length > 0)
+        prompt.push({ role: "assistant", content });
+      continue;
+    }
+    prompt.push({
+      role: "user",
+      content: contentBlocksToPromptParts(message.content)
+    });
+  }
+  return prompt;
+}
+function contentBlocksToPromptParts(content) {
+  return content.map((block) => {
+    if (block.type === "text")
+      return { type: "text", text: block.text };
+    return {
+      type: "file",
+      data: block.data,
+      mediaType: block.mimeType
+    };
+  });
+}
+function toolCallsToPromptParts(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0)
+    return [];
+  return toolCalls.map((toolCall) => ({
+    type: "tool-call",
+    toolCallId: toolCall.id,
+    toolName: toolCall.function.name,
+    input: toolCall.function.arguments
+  }));
+}
+function toolMessageToPrompt(message) {
+  return {
+    role: "tool",
+    content: [{
+      type: "tool-result",
+      toolCallId: message.toolCallId,
+      toolName: message.toolName,
+      output: toolMessageToOutput(message)
+    }]
+  };
+}
+function toolMessageToOutput(message) {
+  if (message.structuredContent) {
+    assertJsonSafeObject(message.structuredContent, "Tool structuredContent");
+    return {
+      type: "json",
+      value: message.structuredContent
+    };
+  }
+  const text = contentToText(message.content);
+  if (message.isError === true) {
+    return {
+      type: "json",
+      value: {
+        content: text,
+        isError: true
+      }
+    };
+  }
+  return {
+    type: "text",
+    value: text
+  };
+}
+
+// src/providers/openai/driver.ts
+var DEFAULT_BASE_URL = "https://api.openai.com/v1";
+var PLACEHOLDER_API_KEY = "dim-placeholder-key";
+var openAIDriver = {
+  async generate(context) {
+    const model = createProvider(context.options).chat(context.request.model.modelId);
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(context.request.messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions
+    });
+  },
+  normalizeError(error) {
+    if (APICallError.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "openai_http_error",
+        provider: "OpenAI-compatible",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "openai_request_error",
+      error
+    });
+  }
+};
+function createProvider(options) {
+  const stripAuthorization = !options.apiKey && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "OpenAI-compatible",
+    shouldWarn: stripAuthorization
+  });
+  return createOpenAI({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY,
+    baseURL: normalizeBaseUrl(options.baseUrl),
+    headers: options.headers,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+function normalizeBaseUrl(baseUrl) {
+  return (baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+}
+
+// src/providers/openai/adapter.ts
+var createOpenAIAdapter = createProviderFactory({
+  defaultProvider: "openai-compatible",
+  driver: openAIDriver
+});
+export {
+  createOpenAIAdapter
+};