@elizaos/plugin-training 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/dspy/artifact.js

@@ -0,0 +1,61 @@
+import { renderDemonstrationsBlock } from "./predict.js";
+function buildDspyArtifact(opts) {
+  const { result } = opts;
+  const sigSpec = result.signature.spec;
+  const promptParts = [result.instructions.trim()];
+  if (result.demonstrations.length > 0) {
+    const demoBlock = renderDemonstrationsBlock(sigSpec, result.demonstrations);
+    if (demoBlock) promptParts.push(demoBlock);
+  }
+  const prompt = promptParts.join("\n\n");
+  return {
+    task: opts.task,
+    optimizer: result.optimizer,
+    baseline: opts.baseline,
+    prompt,
+    score: result.score,
+    baselineScore: result.baselineScore,
+    datasetId: opts.datasetId,
+    datasetSize: opts.datasetSize,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fewShotExamples: result.demonstrations.length > 0 ? result.demonstrations.map(legacyDemoShape) : void 0,
+    lineage: result.lineage,
+    signatureSpec: {
+      name: sigSpec.name,
+      instructions: result.instructions,
+      inputs: sigSpec.inputs,
+      outputs: sigSpec.outputs
+    }
+  };
+}
+function legacyDemoShape(demo) {
+  let system;
+  let user = "";
+  for (const [key, value] of Object.entries(demo.inputs)) {
+    if (key === "system" && typeof value === "string") {
+      system = value;
+      continue;
+    }
+    if (typeof value === "string" && user.length === 0) {
+      user = value;
+    }
+  }
+  let expectedOutput = "";
+  for (const value of Object.values(demo.outputs)) {
+    if (typeof value === "string") {
+      expectedOutput = value;
+      break;
+    }
+  }
+  return {
+    id: demo.source,
+    input: { user, system },
+    expectedOutput,
+    reward: demo.reward,
+    metadata: demo.metadata
+  };
+}
+export {
+  buildDspyArtifact
+};
+//# sourceMappingURL=artifact.js.map

package/dist/dspy/artifact.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dspy/artifact.ts"],"sourcesContent":["/**\n * Translate a DSPy optimizer result into the eliza_native_v1\n * `OptimizedPromptArtifact` shape consumed by\n * `packages/core/src/services/optimized-prompt.ts`.\n *\n * The on-disk parser is strict (rejects unknown optimizer names), so we tag\n * each artifact with its DSPy optimizer name. We extend the OptimizerName\n * union there in a separate edit (see `optimized-prompt.ts`).\n */\n\nimport type { Example } from \"./examples.js\";\nimport type { DspyOptimizerResult } from \"./optimizers/types.js\";\nimport { renderDemonstrationsBlock } from \"./predict.js\";\n\n/** Subset of `TrajectoryTrainingTask` plus the new action-descriptions task. */\nexport type DspyArtifactTask =\n  | \"should_respond\"\n  | \"context_routing\"\n  | \"action_planner\"\n  | \"response\"\n  | \"media_description\"\n  | \"view_context\"\n  | \"calendar_extract\"\n  | \"schedule_plan\"\n  | \"reminder_dispatch\"\n  | \"inbox_triage\"\n  | \"meeting_prep\"\n  | \"morning_brief\"\n  | \"health_checkin\"\n  | \"screentime_recap\"\n  | \"action_descriptions\"\n  | \"autonomy\";\n\nexport interface DspyArtifact {\n  task: DspyArtifactTask;\n  optimizer: \"dspy-bootstrap-fewshot\" | \"dspy-copro\" | \"dspy-mipro\";\n  baseline: string;\n  prompt: string;\n  score: number;\n  baselineScore: number;\n  datasetId: string;\n  datasetSize: number;\n  generatedAt: string;\n  fewShotExamples?: Array<{\n    id?: string;\n    input: { system?: string; user: string };\n    expectedOutput: string;\n    reward?: number;\n    metadata?: Record<string, unknown>;\n  }>;\n  lineage: Array<{\n    round: number;\n    variant: number;\n    score: number;\n    notes?: string;\n  }>;\n  signatureSpec: {\n    name: string;\n    instructions: string;\n    inputs: ReadonlyArray<unknown>;\n    outputs: ReadonlyArray<unknown>;\n  };\n}\n\nexport interface BuildArtifactOptions {\n  task: DspyArtifactTask;\n  baseline: string;\n  datasetId: string;\n  datasetSize: number;\n  result: DspyOptimizerResult;\n}\n\nexport function buildDspyArtifact(opts: BuildArtifactOptions): DspyArtifact {\n  const { result } = opts;\n  const sigSpec = result.signature.spec;\n  // `prompt` is the fully composed system block: instructions + demonstrations.\n  // This is what the runtime substitutes verbatim when it sees the artifact.\n  const promptParts = [result.instructions.trim()];\n  if (result.demonstrations.length > 0) {\n    const demoBlock = renderDemonstrationsBlock(sigSpec, result.demonstrations);\n    if (demoBlock) promptParts.push(demoBlock);\n  }\n  const prompt = promptParts.join(\"\\n\\n\");\n\n  return {\n    task: opts.task,\n    optimizer: result.optimizer,\n    baseline: opts.baseline,\n    prompt,\n    score: result.score,\n    baselineScore: result.baselineScore,\n    datasetId: opts.datasetId,\n    datasetSize: opts.datasetSize,\n    generatedAt: new Date().toISOString(),\n    fewShotExamples:\n      result.demonstrations.length > 0\n        ? result.demonstrations.map(legacyDemoShape)\n        : undefined,\n    lineage: result.lineage,\n    signatureSpec: {\n      name: sigSpec.name,\n      instructions: result.instructions,\n      inputs: sigSpec.inputs,\n      outputs: sigSpec.outputs,\n    },\n  };\n}\n\nfunction legacyDemoShape(demo: Example): {\n  id?: string;\n  input: { system?: string; user: string };\n  expectedOutput: string;\n  reward?: number;\n  metadata?: Record<string, unknown>;\n} {\n  // Collapse our typed input record back into the (system, user) shape the\n  // legacy artifact parser expects. We pick the first string-typed input\n  // field as the canonical `user` payload.\n  let system: string | undefined;\n  let user = \"\";\n  for (const [key, value] of Object.entries(demo.inputs)) {\n    if (key === \"system\" && typeof value === \"string\") {\n      system = value;\n      continue;\n    }\n    if (typeof value === \"string\" && user.length === 0) {\n      user = value;\n    }\n  }\n  let expectedOutput = \"\";\n  for (const value of Object.values(demo.outputs)) {\n    if (typeof value === \"string\") {\n      expectedOutput = value;\n      break;\n    }\n  }\n  return {\n    id: demo.source,\n    input: { user, system },\n    expectedOutput,\n    reward: demo.reward,\n    metadata: demo.metadata,\n  };\n}\n"],"mappings":"AAYA,SAAS,iCAAiC;AA4DnC,SAAS,kBAAkB,MAA0C;AAC1E,QAAM,EAAE,OAAO,IAAI;AACnB,QAAM,UAAU,OAAO,UAAU;AAGjC,QAAM,cAAc,CAAC,OAAO,aAAa,KAAK,CAAC;AAC/C,MAAI,OAAO,eAAe,SAAS,GAAG;AACpC,UAAM,YAAY,0BAA0B,SAAS,OAAO,cAAc;AAC1E,QAAI,UAAW,aAAY,KAAK,SAAS;AAAA,EAC3C;AACA,QAAM,SAAS,YAAY,KAAK,MAAM;AAEtC,SAAO;AAAA,IACL,MAAM,KAAK;AAAA,IACX,WAAW,OAAO;AAAA,IAClB,UAAU,KAAK;AAAA,IACf;AAAA,IACA,OAAO,OAAO;AAAA,IACd,eAAe,OAAO;AAAA,IACtB,WAAW,KAAK;AAAA,IAChB,aAAa,KAAK;AAAA,IAClB,cAAa,oBAAI,KAAK,GAAE,YAAY;AAAA,IACpC,iBACE,OAAO,eAAe,SAAS,IAC3B,OAAO,eAAe,IAAI,eAAe,IACzC;AAAA,IACN,SAAS,OAAO;AAAA,IAChB,eAAe;AAAA,MACb,MAAM,QAAQ;AAAA,MACd,cAAc,OAAO;AAAA,MACrB,QAAQ,QAAQ;AAAA,MAChB,SAAS,QAAQ;AAAA,IACnB;AAAA,EACF;AACF;AAEA,SAAS,gBAAgB,MAMvB;AAIA,MAAI;AACJ,MAAI,OAAO;AACX,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,KAAK,MAAM,GAAG;AACtD,QAAI,QAAQ,YAAY,OAAO,UAAU,UAAU;AACjD,eAAS;AACT;AAAA,IACF;AACA,QAAI,OAAO,UAAU,YAAY,KAAK,WAAW,GAAG;AAClD,aAAO;AAAA,IACT;AAAA,EACF;AACA,MAAI,iBAAiB;AACrB,aAAW,SAAS,OAAO,OAAO,KAAK,OAAO,GAAG;AAC/C,QAAI,OAAO,UAAU,UAAU;AAC7B,uBAAiB;AACjB;AAAA,IACF;AAAA,EACF;AACA,SAAO;AAAA,IACL,IAAI,KAAK;AAAA,IACT,OAAO,EAAE,MAAM,OAAO;AAAA,IACtB;AAAA,IACA,QAAQ,KAAK;AAAA,IACb,UAAU,KAAK;AAAA,EACjB;AACF;","names":[]}

package/dist/dspy/chain-of-thought.d.ts

@@ -0,0 +1,27 @@
+/**
+ * DSPy-style ChainOfThought module (native TS).
+ *
+ * Wraps `Predict` and prepends a `reasoning: string` output field to the
+ * signature so the model thinks step-by-step before emitting the original
+ * outputs. The `reasoning` field is returned alongside `output` for
+ * inspection but is NOT part of the typed output record returned to callers
+ * who don't care about it.
+ */
+import type { UsageInfo } from "./lm-adapter.js";
+import { type PredictOpts, type PredictTrace } from "./predict.js";
+import { Signature } from "./signature.js";
+export interface ChainOfThoughtResult<O extends Record<string, unknown> = Record<string, unknown>> {
+    output: O;
+    reasoning: string;
+    usage: UsageInfo;
+    trace: PredictTrace;
+}
+export declare class ChainOfThought<I extends Record<string, unknown> = Record<string, unknown>, O extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly predict;
+    constructor(opts: PredictOpts<I, O>);
+    get signature(): Signature<I, O & {
+        reasoning: string;
+    }>;
+    forward(input: I): Promise<ChainOfThoughtResult<O>>;
+}
+//# sourceMappingURL=chain-of-thought.d.ts.map

package/dist/dspy/chain-of-thought.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-of-thought.d.ts","sourceRoot":"","sources":["../../src/dspy/chain-of-thought.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAEL,KAAK,WAAW,EAEhB,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAkB,SAAS,EAAsB,MAAM,gBAAgB,CAAC;AAE/E,MAAM,WAAW,oBAAoB,CACnC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAE3D,MAAM,EAAE,CAAC,CAAC;IACV,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB,KAAK,EAAE,YAAY,CAAC;CACrB;AASD,qBAAa,cAAc,CACzB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3D,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAE3D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;gBAEpD,IAAI,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC;IAQnC,IAAI,SAAS,IAAI,SAAS,CAAC,CAAC,EAAE,CAAC,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAEvD;IAEK,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;CAgB1D"}

package/dist/dspy/chain-of-thought.js

@@ -0,0 +1,43 @@
+import {
+  Predict
+} from "./predict.js";
+import { Signature } from "./signature.js";
+const REASONING_FIELD = {
+  name: "reasoning",
+  description: "Step-by-step reasoning that leads to the answer. Be terse \u2014 list the salient facts and the deduction, not commentary.",
+  type: "string"
+};
+class ChainOfThought {
+  predict;
+  constructor(opts) {
+    const augmented = augmentSignatureWithReasoning(opts.signature.spec);
+    this.predict = new Predict({
+      ...opts,
+      signature: new Signature(augmented)
+    });
+  }
+  get signature() {
+    return this.predict.signature;
+  }
+  async forward(input) {
+    const result = await this.predict.forward(input);
+    const { reasoning, ...rest } = result.output;
+    return {
+      output: rest,
+      reasoning: typeof reasoning === "string" ? reasoning : "",
+      usage: result.usage,
+      trace: result.trace
+    };
+  }
+}
+function augmentSignatureWithReasoning(spec) {
+  const outputs = [REASONING_FIELD, ...spec.outputs];
+  return {
+    ...spec,
+    outputs
+  };
+}
+export {
+  ChainOfThought
+};
+//# sourceMappingURL=chain-of-thought.js.map

package/dist/dspy/chain-of-thought.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dspy/chain-of-thought.ts"],"sourcesContent":["/**\n * DSPy-style ChainOfThought module (native TS).\n *\n * Wraps `Predict` and prepends a `reasoning: string` output field to the\n * signature so the model thinks step-by-step before emitting the original\n * outputs. The `reasoning` field is returned alongside `output` for\n * inspection but is NOT part of the typed output record returned to callers\n * who don't care about it.\n */\n\nimport type { UsageInfo } from \"./lm-adapter.js\";\nimport {\n  Predict,\n  type PredictOpts,\n  type PredictResult,\n  type PredictTrace,\n} from \"./predict.js\";\nimport { type FieldSpec, Signature, type SignatureSpec } from \"./signature.js\";\n\nexport interface ChainOfThoughtResult<\n  O extends Record<string, unknown> = Record<string, unknown>,\n> {\n  output: O;\n  reasoning: string;\n  usage: UsageInfo;\n  trace: PredictTrace;\n}\n\nconst REASONING_FIELD: FieldSpec = {\n  name: \"reasoning\",\n  description:\n    \"Step-by-step reasoning that leads to the answer. Be terse — list the salient facts and the deduction, not commentary.\",\n  type: \"string\",\n};\n\nexport class ChainOfThought<\n  I extends Record<string, unknown> = Record<string, unknown>,\n  O extends Record<string, unknown> = Record<string, unknown>,\n> {\n  private readonly predict: Predict<I, O & { reasoning: string }>;\n\n  constructor(opts: PredictOpts<I, O>) {\n    const augmented = augmentSignatureWithReasoning(opts.signature.spec);\n    this.predict = new Predict<I, O & { reasoning: string }>({\n      ...opts,\n      signature: new Signature<I, O & { reasoning: string }>(augmented),\n    });\n  }\n\n  get signature(): Signature<I, O & { reasoning: string }> {\n    return this.predict.signature;\n  }\n\n  async forward(input: I): Promise<ChainOfThoughtResult<O>> {\n    const result: PredictResult<O & { reasoning: string }> =\n      await this.predict.forward(input);\n    const { reasoning, ...rest } = result.output;\n    // `rest` has type `Omit<O & { reasoning: string }, \"reasoning\">`, which\n    // is structurally equal to `O` (we only added `reasoning` ourselves and\n    // just removed it). TS cannot prove this through Omit-on-intersection,\n    // so the double-cast is the minimal type assertion to bridge the\n    // destructure to O.\n    return {\n      output: rest as unknown as O,\n      reasoning: typeof reasoning === \"string\" ? reasoning : \"\",\n      usage: result.usage,\n      trace: result.trace,\n    };\n  }\n}\n\nfunction augmentSignatureWithReasoning(spec: SignatureSpec): SignatureSpec {\n  // Reasoning is the first output field — DSPy's convention. The renderer\n  // then asks the model to print `reasoning:` before any other field, which\n  // is the literal \"think then answer\" effect.\n  const outputs: FieldSpec[] = [REASONING_FIELD, ...spec.outputs];\n  return {\n    ...spec,\n    outputs,\n  };\n}\n"],"mappings":"AAWA;AAAA,EACE;AAAA,OAIK;AACP,SAAyB,iBAAqC;AAW9D,MAAM,kBAA6B;AAAA,EACjC,MAAM;AAAA,EACN,aACE;AAAA,EACF,MAAM;AACR;AAEO,MAAM,eAGX;AAAA,EACiB;AAAA,EAEjB,YAAY,MAAyB;AACnC,UAAM,YAAY,8BAA8B,KAAK,UAAU,IAAI;AACnE,SAAK,UAAU,IAAI,QAAsC;AAAA,MACvD,GAAG;AAAA,MACH,WAAW,IAAI,UAAwC,SAAS;AAAA,IAClE,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,YAAqD;AACvD,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,MAAM,QAAQ,OAA4C;AACxD,UAAM,SACJ,MAAM,KAAK,QAAQ,QAAQ,KAAK;AAClC,UAAM,EAAE,WAAW,GAAG,KAAK,IAAI,OAAO;AAMtC,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,WAAW,OAAO,cAAc,WAAW,YAAY;AAAA,MACvD,OAAO,OAAO;AAAA,MACd,OAAO,OAAO;AAAA,IAChB;AAAA,EACF;AACF;AAEA,SAAS,8BAA8B,MAAoC;AAIzE,QAAM,UAAuB,CAAC,iBAAiB,GAAG,KAAK,OAAO;AAC9D,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EACF;AACF;","names":[]}

package/dist/dspy/examples.d.ts

@@ -0,0 +1,72 @@
+/**
+ * DSPy-style Example primitive + loader for the eliza_native_v1 JSONL shape.
+ *
+ * The loader walks each row, extracts `(system, user) → expected output`
+ * (mirroring the legacy `optimizations.OptimizationExample` flow), and runs
+ * the rows through the mandatory privacy filter from `core/privacy-filter.ts`.
+ * No file path is allowed to skip the filter — that's a CLAUDE.md hard rule.
+ */
+import { type FilterableTrajectory, type PrivacyFilterOptions } from "../core/privacy-filter.js";
+export interface Example {
+    inputs: Record<string, unknown>;
+    outputs: Record<string, unknown>;
+    reward?: number;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+interface JsonlMessage {
+    role: "system" | "developer" | "user" | "assistant" | "tool";
+    content: string;
+}
+interface JsonlRow {
+    format: "eliza_native_v1";
+    boundary?: string;
+    request?: {
+        system?: string;
+        prompt?: string;
+        messages?: JsonlMessage[];
+    };
+    response?: {
+        text?: string;
+        toolCalls?: unknown[];
+    };
+    metadata?: Record<string, unknown>;
+}
+export interface LoadExamplesOptions {
+    /**
+     * Input-field name used when collapsing the (system, user) pair into a
+     * single string for downstream signatures. Defaults to `"input"`.
+     */
+    inputField?: string;
+    /**
+     * Output-field name expected by the consuming Signature. Defaults to
+     * `"output"`.
+     */
+    outputField?: string;
+    /**
+     * Optional privacy-filter options forwarded to `applyPrivacyFilter`.
+     * Even when this is `undefined`, the filter still runs with defaults —
+     * see `runPrivacyFilter()` below.
+     */
+    privacy?: PrivacyFilterOptions;
+}
+/**
+ * Load `eliza_native_v1` JSONL into Example[]. Privacy filter is mandatory.
+ *
+ * Returns the filtered examples plus the redaction/anonymization counts so
+ * callers can log them (or fail loud if a strict-mode flag is added later).
+ */
+export interface LoadExamplesResult {
+    examples: Example[];
+    redactionCount: number;
+    anonymizationCount: number;
+    droppedTrajectories: number;
+}
+export declare function loadExamplesFromElizaV1(path: string, options?: LoadExamplesOptions): LoadExamplesResult;
+/**
+ * In-memory variant — for tests and callers that already have the parsed
+ * rows in hand. Goes through the same privacy filter as the file loader.
+ */
+export declare function buildExamplesFromRows(rows: JsonlRow[], options?: LoadExamplesOptions): LoadExamplesResult;
+export type { FilterableTrajectory };
+//# sourceMappingURL=examples.d.ts.map

package/dist/dspy/examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../../src/dspy/examples.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,QAAQ,GAAG,WAAW,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IAC7D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,QAAQ;IAChB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC;KACvB,CAAC;IACF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CAmBpB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EAAE,EAChB,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CAEpB;AA2FD,YAAY,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/dspy/examples.js

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from "node:fs";
+import {
+  applyPrivacyFilter
+} from "../core/privacy-filter.js";
+function loadExamplesFromElizaV1(path, options = {}) {
+  if (!existsSync(path)) {
+    throw new Error(`[dspy/examples] dataset not found at ${path}`);
+  }
+  const raw = readFileSync(path, "utf-8");
+  const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+  const rows = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!line) continue;
+    const parsed = JSON.parse(line);
+    if (!isJsonlRow(parsed)) {
+      throw new Error(
+        `[dspy/examples] dataset line ${i + 1} is not an eliza_native_v1 row`
+      );
+    }
+    rows.push(parsed);
+  }
+  return rowsToExamples(rows, options);
+}
+function buildExamplesFromRows(rows, options = {}) {
+  return rowsToExamples(rows, options);
+}
+function rowsToExamples(rows, options) {
+  const inputField = options.inputField ?? "input";
+  const outputField = options.outputField ?? "output";
+  const trajectories = rows.map((row, idx) => ({
+    trajectoryId: `row-${idx}`,
+    steps: [
+      {
+        llmCalls: [
+          {
+            systemPrompt: row.request?.system ?? "",
+            userPrompt: extractUser(row),
+            response: extractExpected(row)
+          }
+        ],
+        providerAccesses: []
+      }
+    ],
+    metadata: row.metadata
+  }));
+  const filtered = applyPrivacyFilter(trajectories, options.privacy ?? {});
+  const examples = [];
+  for (let i = 0; i < filtered.trajectories.length; i += 1) {
+    const trajectory = filtered.trajectories[i];
+    if (!trajectory) continue;
+    const call = trajectory.steps?.[0]?.llmCalls?.[0];
+    const userPrompt = call?.userPrompt;
+    const expected = call?.response;
+    if (!userPrompt || !expected) continue;
+    const inputs = { [inputField]: userPrompt };
+    if (typeof call?.systemPrompt === "string" && call.systemPrompt.length > 0) {
+      inputs.system = call.systemPrompt;
+    }
+    examples.push({
+      inputs,
+      outputs: { [outputField]: expected },
+      source: trajectory.trajectoryId,
+      metadata: trajectory.metadata
+    });
+  }
+  return {
+    examples,
+    redactionCount: filtered.redactionCount,
+    anonymizationCount: filtered.anonymizationCount,
+    droppedTrajectories: filtered.dropped.length
+  };
+}
+function isJsonlRow(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.format === "eliza_native_v1";
+}
+function extractUser(row) {
+  const messages = row.request?.messages ?? [];
+  const userTurns = messages.filter((m) => m.role === "user" && typeof m.content === "string").map((m) => m.content);
+  if (userTurns.length > 0) return userTurns.join("\n");
+  return row.request?.prompt ?? "";
+}
+function extractExpected(row) {
+  if (row.response?.text && row.response.text.length > 0) {
+    return row.response.text;
+  }
+  if (Array.isArray(row.response?.toolCalls)) {
+    return JSON.stringify({ toolCalls: row.response.toolCalls });
+  }
+  const messages = row.request?.messages ?? [];
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i];
+    if (msg?.role === "assistant" && typeof msg.content === "string") {
+      return msg.content;
+    }
+  }
+  return "";
+}
+export {
+  buildExamplesFromRows,
+  loadExamplesFromElizaV1
+};
+//# sourceMappingURL=examples.js.map

package/dist/dspy/examples.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dspy/examples.ts"],"sourcesContent":["/**\n * DSPy-style Example primitive + loader for the eliza_native_v1 JSONL shape.\n *\n * The loader walks each row, extracts `(system, user) → expected output`\n * (mirroring the legacy `optimizations.OptimizationExample` flow), and runs\n * the rows through the mandatory privacy filter from `core/privacy-filter.ts`.\n * No file path is allowed to skip the filter — that's a CLAUDE.md hard rule.\n */\n\nimport { existsSync, readFileSync } from \"node:fs\";\nimport {\n  applyPrivacyFilter,\n  type FilterableTrajectory,\n  type PrivacyFilterOptions,\n} from \"../core/privacy-filter.js\";\n\nexport interface Example {\n  inputs: Record<string, unknown>;\n  outputs: Record<string, unknown>;\n  reward?: number;\n  source?: string;\n  metadata?: Record<string, unknown>;\n}\n\ninterface JsonlMessage {\n  role: \"system\" | \"developer\" | \"user\" | \"assistant\" | \"tool\";\n  content: string;\n}\n\ninterface JsonlRow {\n  format: \"eliza_native_v1\";\n  boundary?: string;\n  request?: {\n    system?: string;\n    prompt?: string;\n    messages?: JsonlMessage[];\n  };\n  response?: {\n    text?: string;\n    toolCalls?: unknown[];\n  };\n  metadata?: Record<string, unknown>;\n}\n\nexport interface LoadExamplesOptions {\n  /**\n   * Input-field name used when collapsing the (system, user) pair into a\n   * single string for downstream signatures. Defaults to `\"input\"`.\n   */\n  inputField?: string;\n  /**\n   * Output-field name expected by the consuming Signature. Defaults to\n   * `\"output\"`.\n   */\n  outputField?: string;\n  /**\n   * Optional privacy-filter options forwarded to `applyPrivacyFilter`.\n   * Even when this is `undefined`, the filter still runs with defaults —\n   * see `runPrivacyFilter()` below.\n   */\n  privacy?: PrivacyFilterOptions;\n}\n\n/**\n * Load `eliza_native_v1` JSONL into Example[]. Privacy filter is mandatory.\n *\n * Returns the filtered examples plus the redaction/anonymization counts so\n * callers can log them (or fail loud if a strict-mode flag is added later).\n */\nexport interface LoadExamplesResult {\n  examples: Example[];\n  redactionCount: number;\n  anonymizationCount: number;\n  droppedTrajectories: number;\n}\n\nexport function loadExamplesFromElizaV1(\n  path: string,\n  options: LoadExamplesOptions = {},\n): LoadExamplesResult {\n  if (!existsSync(path)) {\n    throw new Error(`[dspy/examples] dataset not found at ${path}`);\n  }\n  const raw = readFileSync(path, \"utf-8\");\n  const lines = raw.split(\"\\n\").filter((line) => line.trim().length > 0);\n  const rows: JsonlRow[] = [];\n  for (let i = 0; i < lines.length; i += 1) {\n    const line = lines[i];\n    if (!line) continue;\n    const parsed: unknown = JSON.parse(line);\n    if (!isJsonlRow(parsed)) {\n      throw new Error(\n        `[dspy/examples] dataset line ${i + 1} is not an eliza_native_v1 row`,\n      );\n    }\n    rows.push(parsed);\n  }\n  return rowsToExamples(rows, options);\n}\n\n/**\n * In-memory variant — for tests and callers that already have the parsed\n * rows in hand. Goes through the same privacy filter as the file loader.\n */\nexport function buildExamplesFromRows(\n  rows: JsonlRow[],\n  options: LoadExamplesOptions = {},\n): LoadExamplesResult {\n  return rowsToExamples(rows, options);\n}\n\nfunction rowsToExamples(\n  rows: JsonlRow[],\n  options: LoadExamplesOptions,\n): LoadExamplesResult {\n  const inputField = options.inputField ?? \"input\";\n  const outputField = options.outputField ?? \"output\";\n\n  // Run privacy filter BEFORE turning rows into Examples — the filter walks\n  // the `steps[].llmCalls[]` shape, which is what we adapt the rows into.\n  const trajectories: FilterableTrajectory[] = rows.map((row, idx) => ({\n    trajectoryId: `row-${idx}`,\n    steps: [\n      {\n        llmCalls: [\n          {\n            systemPrompt: row.request?.system ?? \"\",\n            userPrompt: extractUser(row),\n            response: extractExpected(row),\n          },\n        ],\n        providerAccesses: [],\n      },\n    ],\n    metadata: row.metadata,\n  }));\n\n  const filtered = applyPrivacyFilter(trajectories, options.privacy ?? {});\n  const examples: Example[] = [];\n  for (let i = 0; i < filtered.trajectories.length; i += 1) {\n    const trajectory = filtered.trajectories[i];\n    if (!trajectory) continue;\n    const call = trajectory.steps?.[0]?.llmCalls?.[0];\n    const userPrompt = call?.userPrompt;\n    const expected = call?.response;\n    if (!userPrompt || !expected) continue;\n    const inputs: Record<string, unknown> = { [inputField]: userPrompt };\n    if (\n      typeof call?.systemPrompt === \"string\" &&\n      call.systemPrompt.length > 0\n    ) {\n      inputs.system = call.systemPrompt;\n    }\n    examples.push({\n      inputs,\n      outputs: { [outputField]: expected },\n      source: trajectory.trajectoryId,\n      metadata: trajectory.metadata,\n    });\n  }\n  return {\n    examples,\n    redactionCount: filtered.redactionCount,\n    anonymizationCount: filtered.anonymizationCount,\n    droppedTrajectories: filtered.dropped.length,\n  };\n}\n\nfunction isJsonlRow(value: unknown): value is JsonlRow {\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as JsonlRow;\n  return candidate.format === \"eliza_native_v1\";\n}\n\nfunction extractUser(row: JsonlRow): string {\n  const messages = row.request?.messages ?? [];\n  const userTurns = messages\n    .filter((m) => m.role === \"user\" && typeof m.content === \"string\")\n    .map((m) => m.content);\n  if (userTurns.length > 0) return userTurns.join(\"\\n\");\n  return row.request?.prompt ?? \"\";\n}\n\nfunction extractExpected(row: JsonlRow): string {\n  if (row.response?.text && row.response.text.length > 0) {\n    return row.response.text;\n  }\n  if (Array.isArray(row.response?.toolCalls)) {\n    return JSON.stringify({ toolCalls: row.response.toolCalls });\n  }\n  const messages = row.request?.messages ?? [];\n  for (let i = messages.length - 1; i >= 0; i -= 1) {\n    const msg = messages[i];\n    if (msg?.role === \"assistant\" && typeof msg.content === \"string\") {\n      return msg.content;\n    }\n  }\n  return \"\";\n}\n\nexport type { FilterableTrajectory };\n"],"mappings":"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","names":[]}

package/dist/dspy/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * DSPy-style primitives (native TS).
+ *
+ * No `@ax-llm/ax`, `dspy`, or `ax` dependency — this is our own implementation
+ * of Signature, Predict, ChainOfThought, plus the BootstrapFewshot / COPRO /
+ * MIPROv2 optimizers and the eliza_native_v1-compatible artifact shape.
+ */
+export { type BuildArtifactOptions, buildDspyArtifact, type DspyArtifact, type DspyArtifactTask, } from "./artifact.js";
+export { ChainOfThought, type ChainOfThoughtResult, } from "./chain-of-thought.js";
+export { buildExamplesFromRows, type Example, type LoadExamplesOptions, type LoadExamplesResult, loadExamplesFromElizaV1, } from "./examples.js";
+export { CerebrasAdapter, type ChatMessage, type GenerateArgs, type GenerateResult, type LanguageModelAdapter, legacyAdapterToLm, MockAdapter, type MockAdapterOptions, type MockRule, type UsageInfo, type UseModelLike, } from "./lm-adapter.js";
+export * from "./optimizers/index.js";
+export { Predict, type PredictOpts, type PredictResult, type PredictTrace, renderDemonstrationsBlock, } from "./predict.js";
+export { defineSignature, type FieldSpec, type FieldType, type RenderedPrompt, Signature, SignatureParseError, type SignatureSpec, } from "./signature.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/dspy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dspy/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,oBAAoB,EACzB,iBAAiB,EACjB,KAAK,YAAY,EACjB,KAAK,gBAAgB,GACtB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,GAC1B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,qBAAqB,EACrB,KAAK,OAAO,EACZ,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,iBAAiB,EACjB,WAAW,EACX,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,YAAY,GAClB,MAAM,iBAAiB,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,OAAO,EACL,OAAO,EACP,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,eAAe,EACf,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,SAAS,EACT,mBAAmB,EACnB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC"}

package/dist/dspy/index.js

@@ -0,0 +1,40 @@
+import {
+  buildDspyArtifact
+} from "./artifact.js";
+import {
+  ChainOfThought
+} from "./chain-of-thought.js";
+import {
+  buildExamplesFromRows,
+  loadExamplesFromElizaV1
+} from "./examples.js";
+import {
+  CerebrasAdapter,
+  legacyAdapterToLm,
+  MockAdapter
+} from "./lm-adapter.js";
+export * from "./optimizers/index.js";
+import {
+  Predict,
+  renderDemonstrationsBlock
+} from "./predict.js";
+import {
+  defineSignature,
+  Signature,
+  SignatureParseError
+} from "./signature.js";
+export {
+  CerebrasAdapter,
+  ChainOfThought,
+  MockAdapter,
+  Predict,
+  Signature,
+  SignatureParseError,
+  buildDspyArtifact,
+  buildExamplesFromRows,
+  defineSignature,
+  legacyAdapterToLm,
+  loadExamplesFromElizaV1,
+  renderDemonstrationsBlock
+};
+//# sourceMappingURL=index.js.map

package/dist/dspy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dspy/index.ts"],"sourcesContent":["/**\n * DSPy-style primitives (native TS).\n *\n * No `@ax-llm/ax`, `dspy`, or `ax` dependency — this is our own implementation\n * of Signature, Predict, ChainOfThought, plus the BootstrapFewshot / COPRO /\n * MIPROv2 optimizers and the eliza_native_v1-compatible artifact shape.\n */\n\nexport {\n  type BuildArtifactOptions,\n  buildDspyArtifact,\n  type DspyArtifact,\n  type DspyArtifactTask,\n} from \"./artifact.js\";\nexport {\n  ChainOfThought,\n  type ChainOfThoughtResult,\n} from \"./chain-of-thought.js\";\nexport {\n  buildExamplesFromRows,\n  type Example,\n  type LoadExamplesOptions,\n  type LoadExamplesResult,\n  loadExamplesFromElizaV1,\n} from \"./examples.js\";\nexport {\n  CerebrasAdapter,\n  type ChatMessage,\n  type GenerateArgs,\n  type GenerateResult,\n  type LanguageModelAdapter,\n  legacyAdapterToLm,\n  MockAdapter,\n  type MockAdapterOptions,\n  type MockRule,\n  type UsageInfo,\n  type UseModelLike,\n} from \"./lm-adapter.js\";\nexport * from \"./optimizers/index.js\";\nexport {\n  Predict,\n  type PredictOpts,\n  type PredictResult,\n  type PredictTrace,\n  renderDemonstrationsBlock,\n} from \"./predict.js\";\nexport {\n  defineSignature,\n  type FieldSpec,\n  type FieldType,\n  type RenderedPrompt,\n  Signature,\n  SignatureParseError,\n  type SignatureSpec,\n} from \"./signature.js\";\n"],"mappings":"AAQA;AAAA,EAEE;AAAA,OAGK;AACP;AAAA,EACE;AAAA,OAEK;AACP;AAAA,EACE;AAAA,EAIA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EAKA;AAAA,EACA;AAAA,OAKK;AACP,cAAc;AACd;AAAA,EACE;AAAA,EAIA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EAIA;AAAA,EACA;AAAA,OAEK;","names":[]}

package/dist/dspy/lm-adapter.d.ts

@@ -0,0 +1,100 @@
+/**
+ * DSPy-style LanguageModelAdapter — abstracts Cerebras / Anthropic / OpenAI /
+ * mock implementations behind one minimal interface so Predict/CoT/optimizers
+ * stay provider-agnostic.
+ *
+ * The existing `LlmAdapter` (in `optimizers/types.ts`) is intentionally narrow
+ * (`complete()` → string) for the legacy three optimizers. The DSPy modules
+ * need slightly richer semantics: a message-array interface plus usage
+ * telemetry. We bridge to the legacy adapter via `legacyAdapterToLm()` for
+ * call-sites that still hold an `LlmAdapter`.
+ */
+import type { LlmAdapter } from "../optimizers/types.js";
+export interface UsageInfo {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    /** Provider-specific cache fields are surfaced verbatim under `cache`. */
+    cache?: Record<string, number>;
+}
+export interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface GenerateArgs {
+    system: string;
+    messages: ChatMessage[];
+    temperature?: number;
+    maxTokens?: number;
+    stop?: string[];
+}
+export interface GenerateResult {
+    text: string;
+    usage: UsageInfo;
+}
+export interface LanguageModelAdapter {
+    name: string;
+    generate(args: GenerateArgs): Promise<GenerateResult>;
+}
+/**
+ * Lift a legacy `LlmAdapter` (which only exposes `complete({system,user})`)
+ * into the DSPy `LanguageModelAdapter` shape. We collapse the message array
+ * by concatenating non-system turns with role tags so the legacy adapter sees
+ * a single composed user prompt — adequate for our scoring loop, which uses
+ * single-turn signatures only.
+ */
+export declare function legacyAdapterToLm(legacy: LlmAdapter, name?: string): LanguageModelAdapter;
+/**
+ * MockAdapter — deterministic, no-network LM for tests.
+ *
+ * The adapter accepts a list of `(systemContains, userContains) → text`
+ * rules and returns the first matching response. The default fallback echoes
+ * the user message so even unconfigured tests get a deterministic string.
+ */
+export interface MockRule {
+    system?: string | RegExp;
+    user?: string | RegExp;
+    response: string;
+}
+export interface MockAdapterOptions {
+    rules?: MockRule[];
+    defaultResponse?: string;
+    /** Optional usage fixture returned with every response. */
+    usage?: UsageInfo;
+    /** Records every call for assertion in tests. */
+    log?: GenerateArgs[];
+}
+export declare class MockAdapter implements LanguageModelAdapter {
+    readonly name = "mock";
+    private readonly rules;
+    private readonly defaultResponse;
+    private readonly usage;
+    private readonly log?;
+    private callCount;
+    constructor(options?: MockAdapterOptions);
+    get calls(): number;
+    generate(args: GenerateArgs): Promise<GenerateResult>;
+}
+/**
+ * Cerebras adapter that routes through the existing
+ * `getTrainingUseModelAdapter()` helper (`lifeops-eval-model.ts`). The helper
+ * already implements gpt-oss-120b auth, reasoning-effort hints, and retry
+ * logic, so we delegate rather than re-implementing the HTTP client.
+ *
+ * The constructor takes the `useModel` callable so this module stays free of
+ * a hard import on `app-lifeops` (it lives in a sibling plugin). Callers
+ * resolve the helper through a dynamic import and inject it here.
+ */
+export type UseModelLike = (input: {
+    prompt: string;
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+}) => Promise<string>;
+export declare class CerebrasAdapter implements LanguageModelAdapter {
+    private readonly useModel;
+    readonly name = "cerebras";
+    constructor(useModel: UseModelLike);
+    generate(args: GenerateArgs): Promise<GenerateResult>;
+}
+//# sourceMappingURL=lm-adapter.d.ts.map

package/dist/dspy/lm-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lm-adapter.d.ts","sourceRoot":"","sources":["../../src/dspy/lm-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD,MAAM,WAAW,SAAS;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACvD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,EAClB,IAAI,SAAW,GACd,oBAAoB,CAkBtB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,iDAAiD;IACjD,GAAG,CAAC,EAAE,YAAY,EAAE,CAAC;CACtB;AAED,qBAAa,WAAY,YAAW,oBAAoB;IACtD,QAAQ,CAAC,IAAI,UAAU;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAiB;IACtC,OAAO,CAAC,SAAS,CAAK;gBAEV,OAAO,GAAE,kBAAuB;IAW5C,IAAI,KAAK,IAAI,MAAM,CAElB;IAEK,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;CAiB5D;AAOD;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEtB,qBAAa,eAAgB,YAAW,oBAAoB;IAG9C,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,QAAQ,CAAC,IAAI,cAAc;gBAEE,QAAQ,EAAE,YAAY;IAE7C,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;CAgB5D"}

package/dist/dspy/lm-adapter.js

@@ -0,0 +1,81 @@
+function legacyAdapterToLm(legacy, name = "legacy") {
+  return {
+    name,
+    async generate(args) {
+      const composed = args.messages.map(
+        (m) => m.role === "user" ? m.content : `[${m.role}]
+${m.content}`
+      ).join("\n\n");
+      const text = await legacy.complete({
+        system: args.system,
+        user: composed,
+        temperature: args.temperature,
+        maxTokens: args.maxTokens
+      });
+      return { text, usage: {} };
+    }
+  };
+}
+class MockAdapter {
+  name = "mock";
+  rules;
+  defaultResponse;
+  usage;
+  log;
+  callCount = 0;
+  constructor(options = {}) {
+    this.rules = options.rules ?? [];
+    this.defaultResponse = options.defaultResponse ?? "";
+    this.usage = options.usage ?? {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+    this.log = options.log;
+  }
+  get calls() {
+    return this.callCount;
+  }
+  async generate(args) {
+    this.callCount += 1;
+    this.log?.push(args);
+    const userContent = args.messages.filter((m) => m.role === "user").map((m) => m.content).join("\n");
+    for (const rule of this.rules) {
+      if (rule.system && !matches(rule.system, args.system)) continue;
+      if (rule.user && !matches(rule.user, userContent)) continue;
+      return { text: rule.response, usage: this.usage };
+    }
+    return {
+      text: this.defaultResponse || userContent,
+      usage: this.usage
+    };
+  }
+}
+function matches(needle, haystack) {
+  if (typeof needle === "string") return haystack.includes(needle);
+  return needle.test(haystack);
+}
+class CerebrasAdapter {
+  constructor(useModel) {
+    this.useModel = useModel;
+  }
+  useModel;
+  name = "cerebras";
+  async generate(args) {
+    const userContent = args.messages.filter((m) => m.role !== "system").map((m) => m.role === "user" ? m.content : `[${m.role}]
+${m.content}`).join("\n\n");
+    const text = await this.useModel({
+      prompt: userContent,
+      systemPrompt: args.system,
+      temperature: args.temperature,
+      maxTokens: args.maxTokens
+    });
+    return { text, usage: {} };
+  }
+}
+export {
+  CerebrasAdapter,
+  MockAdapter,
+  legacyAdapterToLm
+};
+//# sourceMappingURL=lm-adapter.js.map

package/dist/dspy/lm-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dspy/lm-adapter.ts"],"sourcesContent":["/**\n * DSPy-style LanguageModelAdapter — abstracts Cerebras / Anthropic / OpenAI /\n * mock implementations behind one minimal interface so Predict/CoT/optimizers\n * stay provider-agnostic.\n *\n * The existing `LlmAdapter` (in `optimizers/types.ts`) is intentionally narrow\n * (`complete()` → string) for the legacy three optimizers. The DSPy modules\n * need slightly richer semantics: a message-array interface plus usage\n * telemetry. We bridge to the legacy adapter via `legacyAdapterToLm()` for\n * call-sites that still hold an `LlmAdapter`.\n */\n\nimport type { LlmAdapter } from \"../optimizers/types.js\";\n\nexport interface UsageInfo {\n  promptTokens?: number;\n  completionTokens?: number;\n  totalTokens?: number;\n  /** Provider-specific cache fields are surfaced verbatim under `cache`. */\n  cache?: Record<string, number>;\n}\n\nexport interface ChatMessage {\n  role: \"system\" | \"user\" | \"assistant\";\n  content: string;\n}\n\nexport interface GenerateArgs {\n  system: string;\n  messages: ChatMessage[];\n  temperature?: number;\n  maxTokens?: number;\n  stop?: string[];\n}\n\nexport interface GenerateResult {\n  text: string;\n  usage: UsageInfo;\n}\n\nexport interface LanguageModelAdapter {\n  name: string;\n  generate(args: GenerateArgs): Promise<GenerateResult>;\n}\n\n/**\n * Lift a legacy `LlmAdapter` (which only exposes `complete({system,user})`)\n * into the DSPy `LanguageModelAdapter` shape. We collapse the message array\n * by concatenating non-system turns with role tags so the legacy adapter sees\n * a single composed user prompt — adequate for our scoring loop, which uses\n * single-turn signatures only.\n */\nexport function legacyAdapterToLm(\n  legacy: LlmAdapter,\n  name = \"legacy\",\n): LanguageModelAdapter {\n  return {\n    name,\n    async generate(args) {\n      const composed = args.messages\n        .map((m) =>\n          m.role === \"user\" ? m.content : `[${m.role}]\\n${m.content}`,\n        )\n        .join(\"\\n\\n\");\n      const text = await legacy.complete({\n        system: args.system,\n        user: composed,\n        temperature: args.temperature,\n        maxTokens: args.maxTokens,\n      });\n      return { text, usage: {} };\n    },\n  };\n}\n\n/**\n * MockAdapter — deterministic, no-network LM for tests.\n *\n * The adapter accepts a list of `(systemContains, userContains) → text`\n * rules and returns the first matching response. The default fallback echoes\n * the user message so even unconfigured tests get a deterministic string.\n */\nexport interface MockRule {\n  system?: string | RegExp;\n  user?: string | RegExp;\n  response: string;\n}\n\nexport interface MockAdapterOptions {\n  rules?: MockRule[];\n  defaultResponse?: string;\n  /** Optional usage fixture returned with every response. */\n  usage?: UsageInfo;\n  /** Records every call for assertion in tests. */\n  log?: GenerateArgs[];\n}\n\nexport class MockAdapter implements LanguageModelAdapter {\n  readonly name = \"mock\";\n  private readonly rules: MockRule[];\n  private readonly defaultResponse: string;\n  private readonly usage: UsageInfo;\n  private readonly log?: GenerateArgs[];\n  private callCount = 0;\n\n  constructor(options: MockAdapterOptions = {}) {\n    this.rules = options.rules ?? [];\n    this.defaultResponse = options.defaultResponse ?? \"\";\n    this.usage = options.usage ?? {\n      promptTokens: 0,\n      completionTokens: 0,\n      totalTokens: 0,\n    };\n    this.log = options.log;\n  }\n\n  get calls(): number {\n    return this.callCount;\n  }\n\n  async generate(args: GenerateArgs): Promise<GenerateResult> {\n    this.callCount += 1;\n    this.log?.push(args);\n    const userContent = args.messages\n      .filter((m) => m.role === \"user\")\n      .map((m) => m.content)\n      .join(\"\\n\");\n    for (const rule of this.rules) {\n      if (rule.system && !matches(rule.system, args.system)) continue;\n      if (rule.user && !matches(rule.user, userContent)) continue;\n      return { text: rule.response, usage: this.usage };\n    }\n    return {\n      text: this.defaultResponse || userContent,\n      usage: this.usage,\n    };\n  }\n}\n\nfunction matches(needle: string | RegExp, haystack: string): boolean {\n  if (typeof needle === \"string\") return haystack.includes(needle);\n  return needle.test(haystack);\n}\n\n/**\n * Cerebras adapter that routes through the existing\n * `getTrainingUseModelAdapter()` helper (`lifeops-eval-model.ts`). The helper\n * already implements gpt-oss-120b auth, reasoning-effort hints, and retry\n * logic, so we delegate rather than re-implementing the HTTP client.\n *\n * The constructor takes the `useModel` callable so this module stays free of\n * a hard import on `app-lifeops` (it lives in a sibling plugin). Callers\n * resolve the helper through a dynamic import and inject it here.\n */\nexport type UseModelLike = (input: {\n  prompt: string;\n  systemPrompt?: string;\n  temperature?: number;\n  maxTokens?: number;\n}) => Promise<string>;\n\nexport class CerebrasAdapter implements LanguageModelAdapter {\n  readonly name = \"cerebras\";\n\n  constructor(private readonly useModel: UseModelLike) {}\n\n  async generate(args: GenerateArgs): Promise<GenerateResult> {\n    const userContent = args.messages\n      .filter((m) => m.role !== \"system\")\n      .map((m) => (m.role === \"user\" ? m.content : `[${m.role}]\\n${m.content}`))\n      .join(\"\\n\\n\");\n    const text = await this.useModel({\n      prompt: userContent,\n      systemPrompt: args.system,\n      temperature: args.temperature,\n      maxTokens: args.maxTokens,\n    });\n    // gpt-oss-120b does not expose per-call cache fields through the existing\n    // helper, so usage stays empty here. The helper-level cache hit-rate\n    // counters live in `lifeops-eval-model.ts` and surface elsewhere.\n    return { text, usage: {} };\n  }\n}\n"],"mappings":"AAoDO,SAAS,kBACd,QACA,OAAO,UACe;AACtB,SAAO;AAAA,IACL;AAAA,IACA,MAAM,SAAS,MAAM;AACnB,YAAM,WAAW,KAAK,SACnB;AAAA,QAAI,CAAC,MACJ,EAAE,SAAS,SAAS,EAAE,UAAU,IAAI,EAAE,IAAI;AAAA,EAAM,EAAE,OAAO;AAAA,MAC3D,EACC,KAAK,MAAM;AACd,YAAM,OAAO,MAAM,OAAO,SAAS;AAAA,QACjC,QAAQ,KAAK;AAAA,QACb,MAAM;AAAA,QACN,aAAa,KAAK;AAAA,QAClB,WAAW,KAAK;AAAA,MAClB,CAAC;AACD,aAAO,EAAE,MAAM,OAAO,CAAC,EAAE;AAAA,IAC3B;AAAA,EACF;AACF;AAwBO,MAAM,YAA4C;AAAA,EAC9C,OAAO;AAAA,EACC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACT,YAAY;AAAA,EAEpB,YAAY,UAA8B,CAAC,GAAG;AAC5C,SAAK,QAAQ,QAAQ,SAAS,CAAC;AAC/B,SAAK,kBAAkB,QAAQ,mBAAmB;AAClD,SAAK,QAAQ,QAAQ,SAAS;AAAA,MAC5B,cAAc;AAAA,MACd,kBAAkB;AAAA,MAClB,aAAa;AAAA,IACf;AACA,SAAK,MAAM,QAAQ;AAAA,EACrB;AAAA,EAEA,IAAI,QAAgB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,SAAS,MAA6C;AAC1D,SAAK,aAAa;AAClB,SAAK,KAAK,KAAK,IAAI;AACnB,UAAM,cAAc,KAAK,SACtB,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAC/B,IAAI,CAAC,MAAM,EAAE,OAAO,EACpB,KAAK,IAAI;AACZ,eAAW,QAAQ,KAAK,OAAO;AAC7B,UAAI,KAAK,UAAU,CAAC,QAAQ,KAAK,QAAQ,KAAK,MAAM,EAAG;AACvD,UAAI,KAAK,QAAQ,CAAC,QAAQ,KAAK,MAAM,WAAW,EAAG;AACnD,aAAO,EAAE,MAAM,KAAK,UAAU,OAAO,KAAK,MAAM;AAAA,IAClD;AACA,WAAO;AAAA,MACL,MAAM,KAAK,mBAAmB;AAAA,MAC9B,OAAO,KAAK;AAAA,IACd;AAAA,EACF;AACF;AAEA,SAAS,QAAQ,QAAyB,UAA2B;AACnE,MAAI,OAAO,WAAW,SAAU,QAAO,SAAS,SAAS,MAAM;AAC/D,SAAO,OAAO,KAAK,QAAQ;AAC7B;AAmBO,MAAM,gBAAgD;AAAA,EAG3D,YAA6B,UAAwB;AAAxB;AAAA,EAAyB;AAAA,EAAzB;AAAA,EAFpB,OAAO;AAAA,EAIhB,MAAM,SAAS,MAA6C;AAC1D,UAAM,cAAc,KAAK,SACtB,OAAO,CAAC,MAAM,EAAE,SAAS,QAAQ,EACjC,IAAI,CAAC,MAAO,EAAE,SAAS,SAAS,EAAE,UAAU,IAAI,EAAE,IAAI;AAAA,EAAM,EAAE,OAAO,EAAG,EACxE,KAAK,MAAM;AACd,UAAM,OAAO,MAAM,KAAK,SAAS;AAAA,MAC/B,QAAQ;AAAA,MACR,cAAc,KAAK;AAAA,MACnB,aAAa,KAAK;AAAA,MAClB,WAAW,KAAK;AAAA,IAClB,CAAC;AAID,WAAO,EAAE,MAAM,OAAO,CAAC,EAAE;AAAA,EAC3B;AACF;","names":[]}