@arnilo/prism 0.3.1 → 0.4.0

package/templates/deep-research/src/index.ts.tmpl

@@ -0,0 +1,53 @@
+import { createAppAgent, createPlannerAgent, createSynthesizerAgent } from "./agent.js";
+import { createClarifyTool, createResearchSearchAdapter, createResearchWebTools } from "./tools.js";
+import type { ResearchFinding, ResearchPlan, ResearchReport } from "./types.js";
+import { createResearchWorkflow, executeResearch } from "./workflow.js";
+
+export {
+  createAppAgent,
+  createPlannerAgent,
+  createSynthesizerAgent,
+  createResearchSearchAdapter,
+  createResearchWebTools,
+  createClarifyTool,
+  createResearchWorkflow,
+  executeResearch,
+  type ResearchPlan,
+  type ResearchFinding,
+  type ResearchReport,
+};
+
+export async function main() {
+  const topic = process.argv.slice(2).join(" ") || "Prism Agent Architecture";
+  console.log(`Starting deep research on: "${topic}"\n`);
+
+  const report = await executeResearch(topic, {
+    onEvent: (event) => {
+      if (event.type === "node_started") {
+        console.log(`  -> [${event.nodeId}] started...`);
+      } else if (event.type === "node_finished") {
+        console.log(`  ✓ [${event.nodeId}] finished`);
+      }
+    },
+  });
+
+  console.log("\n========================================================");
+  console.log(`RESEARCH REPORT: ${report.topic}`);
+  console.log("========================================================");
+  console.log(`\n${report.summary}\n`);
+  console.log("Key Findings:");
+  for (const f of report.findings) {
+    console.log(`- [${f.citationId}] ${f.title}`);
+    console.log(`  ${f.snippet}`);
+    console.log(`  Source: ${f.url}\n`);
+  }
+  console.log("Citations & References:");
+  for (const c of report.citations) {
+    console.log(`  [${c.citationId}] ${c.title} — ${c.url}`);
+  }
+  console.log("========================================================\n");
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  await main();
+}

package/templates/deep-research/src/tests/research.test.ts.tmpl

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { citation, createWebTools } from "@arnilo/prism-web-tools";
+import { createAppAgent, createPlannerAgent } from "../agent.js";
+import { createClarifyTool, createResearchSearchAdapter, formatResearchFindings } from "../tools.js";
+import { createResearchWorkflow, executeResearch } from "../workflow.js";
+
+describe("deep-research template", () => {
+  it("generates research plans with structured query breakdowns", async () => {
+    const planner = createPlannerAgent();
+    const session = planner.createSession({ id: "test-plan" });
+    const result = await session.run("Prism architecture");
+
+    assert.equal(result.status, "succeeded");
+    assert.ok(result.text.length > 0);
+    const plan = JSON.parse(result.text);
+    assert.ok(Array.isArray(plan.queries));
+    assert.ok(plan.queries.length >= 2);
+    assert.ok(plan.queries[0].query);
+    assert.ok(plan.queries[0].aspect);
+  });
+
+  it("produces attributable citations for search findings", async () => {
+    const customUrl = "https://docs.prism.ai/workflows";
+    const customCitation = citation("brave", customUrl);
+
+    const adapter = createResearchSearchAdapter({
+      searchFn: async (query) => [
+        {
+          ...customCitation,
+          title: `Custom result for ${query}`,
+          snippet: "Deterministic snippet for verification",
+          retrievedAt: "2026-08-31T00:00:00.000Z",
+        },
+      ],
+    });
+
+    const response = await adapter.search("workflows", { count: 1 });
+    assert.equal(response.results.length, 1);
+    const finding = formatResearchFindings("workflows", response.results)[0]!;
+
+    assert.equal(finding.url, customUrl);
+    assert.equal(finding.citationId, customCitation.citationId);
+    assert.ok(finding.citationId.startsWith("web:brave:"));
+    assert.equal(finding.title, "Custom result for workflows");
+  });
+
+  it("clarify tool executes human-in-the-loop decision resolution", async () => {
+    let receivedQuestion = "";
+    let receivedChoices: readonly string[] = [];
+
+    const tool = createClarifyTool({
+      onClarify: async (question, choices) => {
+        receivedQuestion = question;
+        receivedChoices = choices;
+        return choices[1]!; // select second choice
+      },
+    });
+
+    const context = {
+      toolCallId: "call-clarify-1",
+      sessionId: "session-1",
+    };
+
+    const result = await tool.execute(
+      {
+        question: "Which aspect of Prism should we focus on?",
+        choices: ["Orchestration DAGs", "Web Tools & Search", "RAG & Citations"],
+      },
+      context,
+    );
+
+    assert.equal(result.name, "clarify_research_scope");
+    assert.equal(receivedQuestion, "Which aspect of Prism should we focus on?");
+    assert.equal(receivedChoices.length, 3);
+    const val = result.value as { question: string; selectedOption: string };
+    assert.equal(val.selectedOption, "Web Tools & Search");
+  });
+
+  it("executes the full research workflow DAG offline within bounded limits", async () => {
+    const events: string[] = [];
+    const report = await executeResearch("Autonomous Agents", {
+      maxIterations: 2,
+      onEvent: (e) => events.push(e.type),
+    });
+
+    assert.ok(report);
+    assert.equal(report.topic, "Autonomous Agents");
+    assert.ok(report.findings.length >= 2);
+    assert.ok(report.citations.length >= 1);
+    assert.ok(report.summary.includes("Autonomous Agents"));
+
+    // Verify all findings carry valid, attributable citation IDs matching citations list
+    const citationIds = new Set(report.citations.map((c) => c.citationId));
+    for (const finding of report.findings) {
+      assert.ok(finding.citationId, "Finding must have a citation ID");
+      assert.ok(citationIds.has(finding.citationId), `Finding citationId ${finding.citationId} must be in report citations`);
+      assert.ok(finding.url.startsWith("https://"), "Finding must have a valid URL");
+    }
+
+    // Verify workflow lifecycle events
+    assert.ok(events.includes("node_started"));
+    assert.ok(events.includes("node_finished"));
+  });
+
+  it("default createAppAgent boots and exposes search tools", async () => {
+    const appAgent = createAppAgent();
+    const session = appAgent.createSession({ id: "app-test" });
+    const result = await session.run("Hello");
+
+    assert.equal(result.status, "succeeded");
+    assert.match(result.text, /Deep Research Agent ready/);
+  });
+});

package/templates/deep-research/src/tools.ts.tmpl

@@ -0,0 +1,86 @@
+import { type ToolDefinition, type ToolExecutionContext, type ToolResult } from "@arnilo/prism";
+import { citation, createWebTools, type WebSearchAdapter, type WebSearchResult } from "@arnilo/prism-web-tools";
+import type { ResearchFinding } from "./types.js";
+
+/**
+ * Creates search tools backed by web-tools with attributable citation IDs.
+ */
+export function createResearchSearchAdapter(options?: {
+  readonly searchFn?: (query: string) => Promise<readonly WebSearchResult[]>;
+}): WebSearchAdapter {
+  return {
+    provider: "brave",
+    search: async (query: string) => {
+      if (options?.searchFn) {
+        const results = await options.searchFn(query);
+        return { provider: "brave", query, results, untrusted: true };
+      }
+      // Offline fallback mock results with attributable citations
+      const url = `https://docs.prism.ai/research/${encodeURIComponent(query.toLowerCase().replace(/\s+/g, "-"))}`;
+      const baseCitation = citation("brave", url);
+      const mockResult: WebSearchResult = {
+        ...baseCitation,
+        title: `Research findings for ${query}`,
+        snippet: `Verified architectural overview and technical analysis regarding ${query}.`,
+        retrievedAt: new Date().toISOString(),
+      };
+      return { provider: "brave", query, results: [mockResult], untrusted: true };
+    },
+  };
+}
+
+
+/**
+ * Create web tools for the research agent.
+ */
+export function createResearchWebTools(adapter: WebSearchAdapter): readonly ToolDefinition[] {
+  return createWebTools({ search: adapter });
+}
+
+/**
+ * Normalizes raw search results into domain ResearchFindings with citations.
+ */
+export function formatResearchFindings(query: string, results: readonly WebSearchResult[]): readonly ResearchFinding[] {
+  return results.map((r) => ({
+    query,
+    title: r.title ?? "Untitled Resource",
+    snippet: r.snippet ?? "",
+    url: r.url,
+    citationId: r.citationId,
+    retrievedAt: r.retrievedAt ?? new Date().toISOString(),
+  }));
+}
+
+/**
+ * Simple Human-in-the-Loop clarify tool for resolving broad research topics.
+ */
+export function createClarifyTool(options: {
+  readonly onClarify?: (question: string, choices: readonly string[]) => Promise<string>;
+}): ToolDefinition {
+  return {
+    name: "clarify_research_scope",
+    description: "Propose clarification questions to the user when a research topic is broad or ambiguous.",
+    parameters: {
+      type: "object",
+      properties: {
+        question: { type: "string" },
+        choices: { type: "array", items: { type: "string" }, minItems: 2 },
+      },
+      required: ["question", "choices"],
+      additionalProperties: false,
+    },
+    execute: async (args: Record<string, unknown>, context: ToolExecutionContext): Promise<ToolResult> => {
+      const question = String(args.question ?? "");
+      const choices = Array.isArray(args.choices) ? (args.choices as string[]) : [];
+      let selected = choices[0] ?? "default";
+      if (options.onClarify) {
+        selected = await options.onClarify(question, choices);
+      }
+      return {
+        toolCallId: context.toolCallId,
+        name: "clarify_research_scope",
+        value: { question, selectedOption: selected },
+      };
+    },
+  };
+}

package/templates/deep-research/src/types.ts.tmpl

@@ -0,0 +1,45 @@
+/**
+ * Deep Research domain types and contracts.
+ */
+
+export interface ResearchQuery {
+  readonly query: string;
+  readonly rationale: string;
+  readonly aspect: string;
+}
+
+export interface ResearchPlan {
+  readonly topic: string;
+  readonly queries: readonly ResearchQuery[];
+  readonly clarifyQuestion?: string;
+  readonly clarifyOptions?: readonly string[];
+}
+
+export interface ResearchFinding {
+  readonly query: string;
+  readonly title: string;
+  readonly snippet: string;
+  readonly url: string;
+  readonly citationId: string;
+  readonly retrievedAt: string;
+}
+
+export interface ResearchCitation {
+  readonly citationId: string;
+  readonly url: string;
+  readonly title: string;
+}
+
+export interface ResearchReport {
+  readonly topic: string;
+  readonly summary: string;
+  readonly findings: readonly ResearchFinding[];
+  readonly citations: readonly ResearchCitation[];
+  readonly iterations: number;
+  readonly completedAt: string;
+}
+
+export interface ClarifyDecision {
+  readonly question: string;
+  readonly selectedOption: string;
+}

package/templates/deep-research/src/workflow.ts.tmpl

@@ -0,0 +1,156 @@
+import { createSecretRedactor } from "@arnilo/prism";
+import {
+  createMemoryWorkflowCheckpoints,
+  defineWorkflow,
+  functionNode,
+  runWorkflow,
+  type WorkflowDefinition,
+  type WorkflowEvent,
+} from "@arnilo/prism-workflows";
+import { createPlannerAgent, createSynthesizerAgent } from "./agent.js";
+import { createResearchSearchAdapter, formatResearchFindings } from "./tools.js";
+import type { ResearchCitation, ResearchFinding, ResearchPlan, ResearchReport } from "./types.js";
+
+export interface ResearchWorkflowOptions {
+  readonly maxIterations?: number;
+  readonly searchAdapter?: import("@arnilo/prism-web-tools").WebSearchAdapter;
+  readonly onEvent?: (event: WorkflowEvent) => void;
+  readonly onClarify?: (question: string, choices: readonly string[]) => Promise<string>;
+}
+
+/**
+ * Builds the deep research workflow DAG.
+ */
+export function createResearchWorkflow(options?: ResearchWorkflowOptions): WorkflowDefinition {
+  const maxIterations = options?.maxIterations ?? 2;
+  const searchAdapter = options?.searchAdapter ?? createResearchSearchAdapter();
+
+  const plan = functionNode({
+    execute: async (ctx) => {
+      const input = (ctx.workflowInput as { topic: string }) ?? { topic: "General Research" };
+      // Planning step: create initial structured plan
+      const planResult: ResearchPlan = {
+        topic: input.topic,
+        queries: [
+          { query: `${input.topic} overview and core architecture`, rationale: "Foundational concepts", aspect: "architecture" },
+          { query: `${input.topic} performance and security considerations`, rationale: "Production considerations", aspect: "security" },
+        ],
+      };
+      return planResult;
+    },
+  });
+
+  const search = functionNode({
+    execute: async (ctx) => {
+      const currentPlan = ctx.upstream.plan as ResearchPlan;
+      const findings: ResearchFinding[] = [];
+
+      for (const query of currentPlan.queries) {
+        const response = await searchAdapter.search(query.query, { count: 2, signal: ctx.signal });
+        const normalized = formatResearchFindings(query.query, response.results);
+        findings.push(...normalized);
+      }
+
+      return { findings };
+    },
+  });
+
+  const refine = functionNode({
+    execute: async (ctx) => {
+      const searchOutput = ctx.upstream.search as { findings: readonly ResearchFinding[] };
+      const currentFindings = [...searchOutput.findings];
+      let iterations = 1;
+
+      // Bounded refine loop: verify aspect coverage and execute additional queries if bounded budget allows
+      if (iterations < maxIterations && currentFindings.length < 4) {
+        iterations += 1;
+        const refineQuery = `${(ctx.upstream.plan as ResearchPlan).topic} best practices`;
+        const extra = await searchAdapter.search(refineQuery, { count: 1, signal: ctx.signal });
+        currentFindings.push(...formatResearchFindings(refineQuery, extra.results));
+      }
+
+      return { findings: currentFindings, iterations };
+    },
+  });
+
+  const synthesize = functionNode({
+    execute: async (ctx) => {
+      const planOutput = ctx.upstream.plan as ResearchPlan;
+      const refineOutput = ctx.upstream.refine as { findings: readonly ResearchFinding[]; iterations: number };
+      const findings = refineOutput.findings;
+
+      // Collect attributable citations
+      const citationsMap = new Map<string, ResearchCitation>();
+      for (const f of findings) {
+        if (!citationsMap.has(f.citationId)) {
+          citationsMap.set(f.citationId, {
+            citationId: f.citationId,
+            url: f.url,
+            title: f.title,
+          });
+        }
+      }
+
+      const citations = Array.from(citationsMap.values());
+      const summary = `Research completed on topic "${planOutput.topic}". Synthesized ${findings.length} findings across ${citations.length} verified sources.`;
+
+      const report: ResearchReport = {
+        topic: planOutput.topic,
+        summary,
+        findings,
+        citations,
+        iterations: refineOutput.iterations,
+        completedAt: new Date().toISOString(),
+      };
+
+      return report;
+    },
+  });
+
+  return defineWorkflow({
+    id: "deep-research-workflow",
+    revision: "1",
+    nodes: { plan, search, refine, synthesize },
+    edges: [
+      ["plan", "search"],
+      ["search", "refine"],
+      ["refine", "synthesize"],
+    ],
+    limits: {
+      maxConcurrency: 2,
+      maxFanOut: 4,
+      maxNodes: 16,
+      maxStateBytes: 65_536,
+    },
+  });
+}
+
+/**
+ * Execute the deep research workflow on a specified topic.
+ */
+export async function executeResearch(
+  topic: string,
+  options?: ResearchWorkflowOptions,
+): Promise<ResearchReport> {
+  const workflow = createResearchWorkflow(options);
+  const redactor = createSecretRedactor([]);
+  const checkpoints = createMemoryWorkflowCheckpoints({ redactor });
+
+  const result = await runWorkflow(
+    workflow,
+    { topic },
+    {
+      checkpoints,
+      redactor,
+      ownership: { tenantId: "research-session" },
+      signal: AbortSignal.timeout(60_000),
+      onEvent: options?.onEvent,
+    },
+  );
+
+  if (result.status !== "completed") {
+    throw new Error(`Research workflow did not complete successfully. Status: ${result.status}`);
+  }
+
+  return result.outputs.synthesize as ResearchReport;
+}

package/templates/deep-research/tsconfig.json.tmpl

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitOverride": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}

package/templates/init/manifest.json

@@ -0,0 +1,5 @@
+{
+  "name": "init",
+  "description": "Minimal starter Prism agent with one selected provider and offline mock test",
+  "version": "0.1.0"
+}

package/templates/init/package.json.tmpl

@@ -7,7 +7,8 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && node --test dist/__tests__/agent.test.js",
-    "start": "npm run build && node dist/index.js"
+    "start": "npm run build && node dist/index.js",
+    "dev": "prism dev"
   },
   "dependencies": {
 __DEPENDENCIES__

package/templates/init/providers.json

@@ -9,89 +9,89 @@
   },
   "openai": {
     "id": "openai",
-    "packageName": "@arnilo/prism-provider-openai",
+    "packageName": "@arnilo/prism-providers",
     "envKey": "OPENAI_API_KEY",
     "envPlaceholder": "sk-...",
     "modelProvider": "openai",
     "modelName": "gpt-5.1",
-    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport { createOpenAIResponsesProvider } from \"@arnilo/prism-provider-openai\";",
+    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport { createOpenAIResponsesProvider } from \"@arnilo/prism-providers/openai\";",
     "providerExpression": "createOpenAIResponsesProvider({\n    apiKey: () => process.env.OPENAI_API_KEY,\n  })",
     "modelExpression": "{ provider: \"openai\", model: \"gpt-5.1\" }"
   },
   "openrouter": {
     "id": "openrouter",
-    "packageName": "@arnilo/prism-provider-openrouter",
+    "packageName": "@arnilo/prism-providers",
     "envKey": "OPENROUTER_API_KEY",
     "envPlaceholder": "sk-or-...",
     "modelProvider": "openrouter",
     "modelName": "anthropic/claude-sonnet-4",
-    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport {\n  createOpenRouterProvider,\n  defineOpenRouterModel,\n} from \"@arnilo/prism-provider-openrouter\";",
+    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport {\n  createOpenRouterProvider,\n  defineOpenRouterModel,\n} from \"@arnilo/prism-providers/openrouter\";",
     "providerExpression": "createOpenRouterProvider({\n    apiKey: () => process.env.OPENROUTER_API_KEY,\n  })",
     "modelExpression": "defineOpenRouterModel({ model: \"anthropic/claude-sonnet-4\" })"
   },
   "kimi": {
     "id": "kimi",
-    "packageName": "@arnilo/prism-provider-kimi",
+    "packageName": "@arnilo/prism-providers",
     "envKey": "KIMI_API_KEY",
     "envPlaceholder": "your-kimi-api-key",
     "modelProvider": "kimi-coding",
     "modelName": "kimi-k2.7-code",
-    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport { createKimiCodingProvider } from \"@arnilo/prism-provider-kimi\";",
+    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport { createKimiCodingProvider } from \"@arnilo/prism-providers/kimi\";",
     "providerExpression": "createKimiCodingProvider({\n    apiKey: () => process.env.KIMI_API_KEY,\n  })",
     "modelExpression": "{ provider: \"kimi-coding\", model: \"kimi-k2.7-code\" }"
   },
   "zai": {
     "id": "zai",
-    "packageName": "@arnilo/prism-provider-zai",
+    "packageName": "@arnilo/prism-providers",
     "envKey": "ZAI_API_KEY",
     "envPlaceholder": "your-zai-api-key",
     "modelProvider": "zai",
     "modelName": "glm-4.7",
-    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport { createZaiProvider } from \"@arnilo/prism-provider-zai\";",
+    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport { createZaiProvider } from \"@arnilo/prism-providers/zai\";",
     "providerExpression": "createZaiProvider({\n    apiKey: () => process.env.ZAI_API_KEY,\n  })",
     "modelExpression": "{ provider: \"zai\", model: \"glm-4.7\" }"
   },
   "opencode-go": {
     "id": "opencode-go",
-    "packageName": "@arnilo/prism-provider-opencode-go",
+    "packageName": "@arnilo/prism-providers",
     "envKey": "OPENCODE_API_KEY",
     "envPlaceholder": "your-opencode-api-key",
     "modelProvider": "opencode-go",
     "modelName": "gpt-5.1-go",
-    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport { createOpenCodeGoProvider } from \"@arnilo/prism-provider-opencode-go\";",
+    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport { createOpenCodeGoProvider } from \"@arnilo/prism-providers/opencode-go\";",
     "providerExpression": "createOpenCodeGoProvider({\n    apiKey: () => process.env.OPENCODE_API_KEY,\n  })",
     "modelExpression": "{ provider: \"opencode-go\", model: \"gpt-5.1-go\", compat: { route: \"openai\" } }"
   },
   "neuralwatt": {
     "id": "neuralwatt",
-    "packageName": "@arnilo/prism-provider-neuralwatt",
+    "packageName": "@arnilo/prism-providers",
     "envKey": "NEURALWATT_API_KEY",
     "envPlaceholder": "your-neuralwatt-api-key",
     "modelProvider": "neuralwatt",
     "modelName": "glm-5.2",
-    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport {\n  createNeuralWattProvider,\n  defineNeuralWattModel,\n} from \"@arnilo/prism-provider-neuralwatt\";",
+    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport {\n  createNeuralWattProvider,\n  defineNeuralWattModel,\n} from \"@arnilo/prism-providers/neuralwatt\";",
     "providerExpression": "createNeuralWattProvider({\n    apiKey: () => process.env.NEURALWATT_API_KEY,\n  })",
     "modelExpression": "defineNeuralWattModel({\n    model: \"glm-5.2\",\n    cache: { kind: \"implicit\" },\n  })"
   },
   "alibaba": {
     "id": "alibaba",
-    "packageName": "@arnilo/prism-provider-alibaba",
+    "packageName": "@arnilo/prism-providers",
     "envKey": "DASHSCOPE_API_KEY",
     "envPlaceholder": "sk-...",
     "modelProvider": "alibaba",
     "modelName": "qwen-plus",
-    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport {\n  createAlibabaProvider,\n  defineAlibabaModel,\n} from \"@arnilo/prism-provider-alibaba\";",
+    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport {\n  createAlibabaProvider,\n  defineAlibabaModel,\n} from \"@arnilo/prism-providers/alibaba\";",
     "providerExpression": "createAlibabaProvider({\n    apiKey: () => process.env.DASHSCOPE_API_KEY,\n  })",
     "modelExpression": "defineAlibabaModel({ model: \"qwen-plus\" })"
   },
   "ollama": {
     "id": "ollama",
-    "packageName": "@arnilo/prism-provider-ollama",
+    "packageName": "@arnilo/prism-providers",
     "envKey": "OLLAMA_API_KEY",
     "envPlaceholder": "your-ollama-api-key",
     "modelProvider": "ollama",
     "modelName": "gpt-oss:20b",
-    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport {\n  createOllamaProvider,\n  defineOllamaModel,\n} from \"@arnilo/prism-provider-ollama\";",
+    "imports": "import { createAgent } from \"@arnilo/prism\";\nimport {\n  createOllamaProvider,\n  defineOllamaModel,\n} from \"@arnilo/prism-providers/ollama\";",
     "providerExpression": "createOllamaProvider({\n    apiKey: () => process.env.OLLAMA_API_KEY,\n  })",
     "modelExpression": "defineOllamaModel({ model: \"gpt-oss:20b\" })"
   }