@digilogiclabs/platform-core 1.15.0 → 1.17.0

package/dist/agents.mjs

@@ -438,8 +438,341 @@ function createTracedAI(options) {
     }
   };
 }
+
+// src/interfaces/IAI.ts
+var AIErrorMessages = {
+  invalid_request: "The request was invalid or malformed",
+  authentication_error: "Authentication failed - check your API key",
+  rate_limit_exceeded: "Rate limit exceeded - try again later",
+  quota_exceeded: "Usage quota exceeded for this billing period",
+  model_not_found: "The specified model was not found",
+  context_length_exceeded: "Input exceeds the model context length",
+  content_filter: "Content was filtered due to policy violations",
+  server_error: "The AI provider encountered an internal error",
+  timeout: "The request timed out",
+  network_error: "Network error connecting to AI provider",
+  provider_unavailable: "The AI provider is currently unavailable",
+  unknown: "An unknown error occurred"
+};
+function createAIError(code, message, options) {
+  const error = new Error(message || AIErrorMessages[code]);
+  error.name = "AIError";
+  error.code = code;
+  error.provider = options?.provider;
+  error.model = options?.model;
+  error.statusCode = options?.statusCode;
+  error.retryable = options?.retryable ?? [
+    "rate_limit_exceeded",
+    "server_error",
+    "timeout",
+    "network_error"
+  ].includes(code);
+  error.retryAfterMs = options?.retryAfterMs;
+  if (options?.cause) {
+    error.cause = options.cause;
+  }
+  return error;
+}
+
+// src/adapters/ollama/OllamaAdapter.ts
+var OllamaAdapter = class {
+  baseUrl;
+  defaultModel;
+  defaultEmbeddingModel;
+  timeoutMs;
+  constructor(config) {
+    this.baseUrl = (config?.baseUrl ?? "http://localhost:11434").replace(
+      /\/$/,
+      ""
+    );
+    this.defaultModel = config?.defaultModel ?? "qwen2.5:3b";
+    this.defaultEmbeddingModel = config?.defaultEmbeddingModel ?? "nomic-embed-text";
+    this.timeoutMs = config?.timeoutMs ?? 12e4;
+  }
+  async chat(request) {
+    const model = request.model ?? this.defaultModel;
+    const ollamaReq = {
+      model,
+      messages: request.messages.map((m) => ({
+        role: m.role === "tool" ? "assistant" : m.role,
+        content: m.content
+      })),
+      stream: false,
+      options: {
+        temperature: request.temperature,
+        num_predict: request.maxTokens,
+        top_p: request.topP,
+        stop: request.stop ? Array.isArray(request.stop) ? request.stop : [request.stop] : void 0
+      }
+    };
+    const response = await this.fetch(
+      "/api/chat",
+      ollamaReq
+    );
+    const usage = {
+      promptTokens: response.prompt_eval_count ?? 0,
+      completionTokens: response.eval_count ?? 0,
+      totalTokens: (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0),
+      estimatedCostUsd: 0
+      // Local — zero cost
+    };
+    return {
+      id: `ollama-${Date.now()}`,
+      model: response.model ?? model,
+      provider: "custom",
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: response.message.content
+          },
+          finishReason: "stop"
+        }
+      ],
+      usage,
+      created: /* @__PURE__ */ new Date(),
+      finishReason: "stop"
+    };
+  }
+  async *chatStream(request) {
+    const model = request.model ?? this.defaultModel;
+    const ollamaReq = {
+      model,
+      messages: request.messages.map((m) => ({
+        role: m.role === "tool" ? "assistant" : m.role,
+        content: m.content
+      })),
+      stream: true,
+      options: {
+        temperature: request.temperature,
+        num_predict: request.maxTokens,
+        top_p: request.topP
+      }
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(`${this.baseUrl}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(ollamaReq),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw createAIError("server_error", `Ollama error: ${res.status}`);
+      }
+      const reader = res.body?.getReader();
+      if (!reader) return;
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          const chunk = JSON.parse(line);
+          yield {
+            id: `ollama-stream-${Date.now()}`,
+            model,
+            provider: "custom",
+            delta: {
+              content: chunk.message?.content ?? ""
+            },
+            finishReason: chunk.done ? "stop" : void 0
+          };
+        }
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async chatWithCallback(request, callback) {
+    let fullContent = "";
+    for await (const chunk of this.chatStream(request)) {
+      await callback(chunk);
+      if (chunk.delta.content) {
+        fullContent += chunk.delta.content;
+      }
+    }
+    const model = request.model ?? this.defaultModel;
+    return {
+      id: `ollama-${Date.now()}`,
+      model,
+      provider: "custom",
+      choices: [
+        {
+          index: 0,
+          message: { role: "assistant", content: fullContent },
+          finishReason: "stop"
+        }
+      ],
+      usage: {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+        estimatedCostUsd: 0
+      },
+      created: /* @__PURE__ */ new Date(),
+      finishReason: "stop"
+    };
+  }
+  async complete(request) {
+    const response = await this.chat({
+      messages: [{ role: "user", content: request.prompt }],
+      model: request.model,
+      temperature: request.temperature,
+      maxTokens: request.maxTokens
+    });
+    return {
+      id: response.id,
+      model: response.model,
+      provider: "custom",
+      text: response.choices[0]?.message.content ?? "",
+      usage: response.usage,
+      created: response.created,
+      finishReason: response.finishReason
+    };
+  }
+  async *completeStream(request) {
+    yield* this.chatStream({
+      messages: [{ role: "user", content: request.prompt }],
+      model: request.model,
+      temperature: request.temperature,
+      maxTokens: request.maxTokens
+    });
+  }
+  async embed(request) {
+    const model = request.model ?? this.defaultEmbeddingModel;
+    const response = await this.fetch("/api/embed", {
+      model,
+      input: request.input
+    });
+    return {
+      id: `ollama-emb-${Date.now()}`,
+      model,
+      provider: "custom",
+      embeddings: response.embeddings,
+      usage: {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+        estimatedCostUsd: 0
+      },
+      created: /* @__PURE__ */ new Date()
+    };
+  }
+  async similarity(text1, text2, model) {
+    const response = await this.embed({ input: [text1, text2], model });
+    const [a, b] = response.embeddings;
+    if (!a || !b) return 0;
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dot += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+  async listModels() {
+    try {
+      const response = await this.fetch(
+        "/api/tags",
+        null,
+        "GET"
+      );
+      return response.models.map((m) => ({
+        modelId: m.name,
+        provider: "custom",
+        capabilities: ["chat", "completion"],
+        maxContextTokens: 4096,
+        maxOutputTokens: 2048,
+        inputCostPer1K: 0,
+        outputCostPer1K: 0,
+        supportsStreaming: true,
+        supportsTools: false,
+        supportsVision: false
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getModel(modelId) {
+    const models = await this.listModels();
+    return models.find((m) => m.modelId === modelId) ?? null;
+  }
+  async supportsCapability(modelId, capability) {
+    const model = await this.getModel(modelId);
+    return model?.capabilities.includes(capability) ?? false;
+  }
+  async estimateTokens(text, _model) {
+    return Math.ceil(text.length / 4);
+  }
+  async estimateCost() {
+    return 0;
+  }
+  async healthCheck() {
+    try {
+      const start = Date.now();
+      await this.fetch("/api/tags", null, "GET");
+      const latency = Date.now() - start;
+      return {
+        healthy: true,
+        providers: {
+          custom: { available: true, latencyMs: latency },
+          openai: { available: false, error: "Not configured" },
+          anthropic: { available: false, error: "Not configured" },
+          google: { available: false, error: "Not configured" },
+          azure: { available: false, error: "Not configured" },
+          bedrock: { available: false, error: "Not configured" }
+        }
+      };
+    } catch (err) {
+      return {
+        healthy: false,
+        providers: {
+          custom: {
+            available: false,
+            error: err instanceof Error ? err.message : "Ollama unavailable"
+          },
+          openai: { available: false, error: "Not configured" },
+          anthropic: { available: false, error: "Not configured" },
+          google: { available: false, error: "Not configured" },
+          azure: { available: false, error: "Not configured" },
+          bedrock: { available: false, error: "Not configured" }
+        }
+      };
+    }
+  }
+  async fetch(path, body, method = "POST") {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers: body ? { "Content-Type": "application/json" } : void 0,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw createAIError(
+          "server_error",
+          `Ollama ${method} ${path}: ${res.status} ${text}`
+        );
+      }
+      return await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
 export {
   DEFAULT_AGENT_LOOP_OPTIONS,
+  OllamaAdapter,
   createAgentTracer,
   createAgentUsageTracker,
   createTracedAI,