@princetheprogrammerbtw/husk 0.1.1 → 0.2.0

package/dist/index.js

@@ -821,6 +821,27 @@ function mapStopReason2(reason) {
   }
 }
 
+// src/providers/ollama.ts
+var DEFAULT_BASE_URL = "http://localhost:11434/v1";
+var DEFAULT_MODEL = "llama3.2";
+var PLACEHOLDER_API_KEY = "ollama";
+var OllamaProvider = class {
+  name = "ollama";
+  model;
+  inner;
+  constructor(options = {}) {
+    this.model = options.model ?? DEFAULT_MODEL;
+    this.inner = new OpenAIProvider({
+      apiKey: options.apiKey ?? PLACEHOLDER_API_KEY,
+      model: this.model,
+      baseURL: options.baseURL ?? DEFAULT_BASE_URL
+    });
+  }
+  chat(request) {
+    return this.inner.chat(request);
+  }
+};
+
 // src/tools/registry.ts
 function defineTool(tool) {
   return {
@@ -1103,9 +1124,293 @@ function truncateOutput(output, limit) {
 ... (${lines.length - limit} more matches truncated)`;
 }
 
+// src/evals/types.ts
+function equals(expected) {
+  return (result) => {
+    const pass = result.output === expected;
+    return pass ? { name: `equals(${JSON.stringify(expected).slice(0, 40)})`, pass: true } : {
+      name: `equals(${JSON.stringify(expected).slice(0, 40)})`,
+      pass: false,
+      message: `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(result.output).slice(0, 200)}`
+    };
+  };
+}
+function contains(needle) {
+  return (result) => {
+    const pass = result.output.includes(needle);
+    return pass ? { name: `contains(${JSON.stringify(needle).slice(0, 40)})`, pass: true } : {
+      name: `contains(${JSON.stringify(needle).slice(0, 40)})`,
+      pass: false,
+      message: `Expected output to contain ${JSON.stringify(needle)}, got ${JSON.stringify(result.output).slice(0, 200)}`
+    };
+  };
+}
+function matches(pattern) {
+  return (result) => {
+    const m = pattern.exec(result.output);
+    return {
+      name: `matches(${pattern})`,
+      pass: m !== null,
+      ...m === null ? {
+        message: `Output did not match ${pattern}: ${JSON.stringify(result.output).slice(0, 200)}`
+      } : {}
+    };
+  };
+}
+function fn(name, predicate, message) {
+  return (result) => {
+    const pass = predicate(result.output);
+    return {
+      name,
+      pass,
+      ...pass ? {} : { message: message ?? `Predicate ${name} failed` }
+    };
+  };
+}
+function notContains(needle) {
+  return (result) => {
+    const pass = !result.output.includes(needle);
+    return pass ? { name: `notContains(${JSON.stringify(needle).slice(0, 40)})`, pass: true } : {
+      name: `notContains(${JSON.stringify(needle).slice(0, 40)})`,
+      pass: false,
+      message: `Output should not contain ${JSON.stringify(needle)} but did: ${JSON.stringify(result.output).slice(0, 200)}`
+    };
+  };
+}
+function lengthBetween(min, max) {
+  return (result) => {
+    const len = result.output.length;
+    const pass = len >= min && len <= max;
+    return pass ? { name: `lengthBetween(${min}, ${max})`, pass: true } : {
+      name: `lengthBetween(${min}, ${max})`,
+      pass: false,
+      message: `Output length ${len} not in [${min}, ${max}]`
+    };
+  };
+}
+
+// src/evals/runner.ts
+async function runSuite(suite, factory, options = {}) {
+  const start = Date.now();
+  const results = [];
+  let passed = 0;
+  for (const c of suite.cases) {
+    options.onCaseStart?.(c.name);
+    const caseResult = await runCase(c, factory);
+    results.push(caseResult);
+    if (caseResult.passed) passed += 1;
+    options.onCaseEnd?.(caseResult);
+    if (options.failFast && !caseResult.passed) {
+      break;
+    }
+  }
+  return {
+    suiteName: suite.name,
+    results,
+    passed,
+    total: suite.cases.length,
+    durationMs: Date.now() - start
+  };
+}
+async function runCase(c, factory) {
+  const start = Date.now();
+  const agent = await factory();
+  let agentResult;
+  try {
+    agentResult = await agent.run(c.input);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const errorAssertionResult = {
+      pass: false,
+      name: "agent.run",
+      message: `agent.run threw: ${message}`
+    };
+    return {
+      caseName: c.name,
+      passed: false,
+      assertionResults: [errorAssertionResult],
+      agentResult: {
+        output: "",
+        messages: [],
+        iterations: 0,
+        usage: { inputTokens: 0, outputTokens: 0 },
+        durationMs: Date.now() - start
+      },
+      durationMs: Date.now() - start
+    };
+  }
+  const assertionResults = [];
+  for (const a of c.assertions) {
+    const r = await a(agentResult);
+    assertionResults.push(r);
+  }
+  const allPassed = assertionResults.every((r) => r.pass);
+  return {
+    caseName: c.name,
+    passed: allPassed,
+    assertionResults,
+    agentResult,
+    durationMs: Date.now() - start
+  };
+}
+function defineSuite(suite) {
+  return {
+    name: suite.name,
+    cases: suite.cases
+  };
+}
+
+// src/obs/tracer.ts
+var NoopTracer = class {
+  startSpan(_options, _parent) {
+    const ctx = {
+      traceId: "0",
+      spanId: "0"
+    };
+    return {
+      context: ctx,
+      addEvent: () => {
+      },
+      setAttribute: () => {
+      },
+      recordException: () => {
+      },
+      setStatus: () => {
+      },
+      end: () => {
+      }
+    };
+  }
+};
+
+// src/obs/mapper.ts
+var EventTracer = class {
+  tracer;
+  traceSpan = null;
+  iterationSpan = null;
+  toolSpans = /* @__PURE__ */ new Map();
+  constructor(tracer) {
+    this.tracer = tracer;
+  }
+  /**
+   * Bind as an event handler: `agent.onAny(tracer.onEvent.bind(tracer))`
+   */
+  onEvent = (event) => {
+    switch (event.type) {
+      case "agent:start": {
+        this.traceSpan = this.tracer.startSpan({
+          name: "agent.run",
+          kind: "internal",
+          attributes: {
+            "husk.input": event.input,
+            "husk.session_id": event.sessionId
+          }
+        });
+        break;
+      }
+      case "agent:iteration": {
+        this.iterationSpan?.end();
+        this.iterationSpan = this.tracer.startSpan(
+          {
+            name: `iteration.${event.iteration}`,
+            kind: "internal",
+            attributes: { "husk.iteration": event.iteration }
+          },
+          this.traceSpan?.context
+        );
+        break;
+      }
+      case "provider:request": {
+        this.iterationSpan?.addEvent("provider.request", {
+          "provider.model": event.request.model
+        });
+        break;
+      }
+      case "provider:response": {
+        if (this.iterationSpan) {
+          this.iterationSpan.setAttribute(
+            "provider.input_tokens",
+            event.response.usage.inputTokens
+          );
+          this.iterationSpan.setAttribute(
+            "provider.output_tokens",
+            event.response.usage.outputTokens
+          );
+          this.iterationSpan.setAttribute("provider.stop_reason", event.response.stopReason);
+          this.iterationSpan.setAttribute("provider.duration_ms", event.durationMs);
+        }
+        break;
+      }
+      case "tool:call": {
+        const span = this.tracer.startSpan(
+          {
+            name: `tool.${event.name}`,
+            kind: "internal",
+            attributes: {
+              "tool.name": event.name,
+              "tool.input": JSON.stringify(event.input)
+            }
+          },
+          this.iterationSpan?.context ?? this.traceSpan?.context
+        );
+        this.toolSpans.set(event.id, span);
+        break;
+      }
+      case "tool:result": {
+        const span = this.toolSpans.get(event.id);
+        if (span) {
+          span.setAttribute("tool.is_error", event.result.isError ?? false);
+          span.setAttribute("tool.duration_ms", event.durationMs);
+          if (event.result.isError) {
+            span.setStatus("error", event.result.output);
+          } else {
+            span.setStatus("ok");
+          }
+          span.end();
+          this.toolSpans.delete(event.id);
+        }
+        break;
+      }
+      case "agent:end": {
+        this.iterationSpan?.end();
+        this.iterationSpan = null;
+        if (this.traceSpan) {
+          this.traceSpan.setAttribute("husk.iterations", event.iterations);
+          this.traceSpan.setAttribute("husk.duration_ms", event.durationMs);
+          this.traceSpan.setStatus("ok");
+          this.traceSpan.end();
+          this.traceSpan = null;
+        }
+        break;
+      }
+      case "agent:error": {
+        if (this.traceSpan) {
+          this.traceSpan.recordException(event.error);
+          this.traceSpan.setStatus("error", event.error.message);
+          this.traceSpan.end();
+          this.traceSpan = null;
+        }
+        this.iterationSpan?.end();
+        this.iterationSpan = null;
+        for (const span of this.toolSpans.values()) {
+          span.end();
+        }
+        this.toolSpans.clear();
+        break;
+      }
+      case "agent:message": {
+        this.iterationSpan?.addEvent("message", {
+          "message.role": event.message.role
+        });
+        break;
+      }
+    }
+  };
+};
+
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { Agent, AgentEventEmitter, AnthropicProvider, Bash, ConsoleLogger, Edit, FileStore, Grep, InMemoryStore, OpenAIProvider, Read, VERSION, Write, arrayField, booleanField, buildExampleMessages, buildSystemPrompt, defineTool, integerField, logEventsTo, numberField, objectField, objectSchema, stringField };
+export { Agent, AgentEventEmitter, AnthropicProvider, Bash, ConsoleLogger, Edit, EventTracer, FileStore, Grep, InMemoryStore, NoopTracer, OllamaProvider, OpenAIProvider, Read, VERSION, Write, arrayField, booleanField, buildExampleMessages, buildSystemPrompt, contains, defineSuite, defineTool, equals, fn, integerField, lengthBetween, logEventsTo, matches, notContains, numberField, objectField, objectSchema, runSuite, stringField };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map