@deepagents/context 7.0.2 → 7.1.0

package/README.md

@@ -28,10 +28,10 @@ like store implementations, sandbox tooling, and filesystem-based skill loading.
 The server-side package also ships the sandbox primitives used by
 `@deepagents/text2sql` and other tool-driven agents. Use `createBashTool()`
 with `createVirtualSandbox()`, `createDockerSandbox()`,
-`createAppleContainerSandbox()`, `createMicrosandboxSandbox()`,
-`createDaytonaSandbox(client, options)`, or `createAgentOsSandbox()` depending
-on whether commands should run in memory, Docker, Apple Container lightweight
-VMs, Microsandbox microVMs, managed Daytona sandboxes, or Agent OS.
+`createAppleContainerSandbox()`, `createMicrosandboxSandbox()`, or
+`createDaytonaSandbox(client, options)` depending on whether commands should
+run in memory, Docker, Apple Container lightweight VMs, Microsandbox microVMs,
+or managed Daytona sandboxes.
 Virtual sandboxes can opt into in-process JavaScript execution with
 `createVirtualSandbox({ javascript: true, ... })`.
 

package/dist/browser.js

@@ -1,8 +1,28 @@
+// packages/context/src/lib/codec/serialized-fragments.ts
+import { z } from "zod";
+
 // packages/context/src/lib/fragments.ts
 import { generateId } from "ai";
 function isFragment(data) {
   return typeof data === "object" && data !== null && "name" in data && ("data" in data || "codec" in data) && typeof data.name === "string";
 }
+function isFragmentData(value) {
+  return fitsFragmentData(value, /* @__PURE__ */ new WeakSet());
+}
+function fitsFragmentData(value, visited) {
+  if (typeof value !== "object") {
+    return typeof value !== "bigint" && typeof value !== "symbol";
+  }
+  if (value === null || visited.has(value)) return true;
+  visited.add(value);
+  if (Array.isArray(value)) {
+    return value.every((item) => fitsFragmentData(item, visited));
+  }
+  if (value instanceof Promise) return true;
+  if (Symbol.asyncIterator in value || Symbol.iterator in value) return true;
+  if (isFragment(value)) return fitsFragmentData(value.data, visited);
+  return Object.values(value).every((item) => fitsFragmentData(item, visited));
+}
 function isFragmentObject(data) {
   if (typeof data !== "object" || data === null) return false;
   if (Array.isArray(data)) return false;
@@ -16,7 +36,13 @@ function isMessageFragment(fragment2) {
 }
 function getFragmentData(fragment2) {
   if (fragment2.codec) {
-    return fragment2.codec.decode();
+    const decoded = fragment2.codec.decode();
+    if (!isFragmentData(decoded)) {
+      throw new Error(
+        `Fragment "${fragment2.name}" codec decoded a value that is not fragment data`
+      );
+    }
+    return decoded;
   }
   if ("data" in fragment2) {
     return fragment2.data;
@@ -589,118 +615,198 @@ function toFragmentData(value, options) {
       ])
     );
   }
+  if (!isFragmentData(value)) {
+    throw new Error(`Unsupported serialized value of type ${typeof value}`);
+  }
   return value;
 }
+function builtInEntry(schema, build) {
+  return {
+    toFragment: (input, options) => {
+      const parsed = schema.safeParse(input);
+      if (!parsed.success) {
+        throw new Error(
+          `Invalid serialized ${input.type} fragment: ${z.prettifyError(parsed.error)}`
+        );
+      }
+      return build(parsed.data, options);
+    }
+  };
+}
+var nestedPolicies = z.array(z.unknown()).optional();
 var builtInSerializedRegistry = {
-  term: {
-    toFragment: (input) => term(input.name, input.definition)
-  },
-  hint: {
-    toFragment: (input) => hint(input.text)
-  },
-  guardrail: {
-    toFragment: (input) => guardrail({
+  term: builtInEntry(
+    z.object({ name: z.string(), definition: z.string() }),
+    (input) => term(input.name, input.definition)
+  ),
+  hint: builtInEntry(
+    z.object({ text: z.string() }),
+    (input) => hint(input.text)
+  ),
+  guardrail: builtInEntry(
+    z.object({
+      rule: z.string(),
+      reason: z.string().optional(),
+      action: z.string().optional()
+    }),
+    (input) => guardrail({
       rule: input.rule,
       reason: input.reason,
       action: input.action
     })
-  },
-  explain: {
-    toFragment: (input) => explain({
+  ),
+  explain: builtInEntry(
+    z.object({
+      concept: z.string(),
+      explanation: z.string(),
+      therefore: z.string().optional()
+    }),
+    (input) => explain({
       concept: input.concept,
       explanation: input.explanation,
       therefore: input.therefore
     })
-  },
-  example: {
-    toFragment: (input) => example({
+  ),
+  example: builtInEntry(
+    z.object({
+      question: z.string(),
+      answer: z.string(),
+      note: z.string().optional()
+    }),
+    (input) => example({
       question: input.question,
       answer: input.answer,
       note: input.note
     })
-  },
-  clarification: {
-    toFragment: (input) => clarification({
+  ),
+  clarification: builtInEntry(
+    z.object({ when: z.string(), ask: z.string(), reason: z.string() }),
+    (input) => clarification({
       when: input.when,
       ask: input.ask,
       reason: input.reason
     })
-  },
-  workflow: {
-    toFragment: (input) => workflow({
+  ),
+  workflow: builtInEntry(
+    z.object({
+      task: z.string(),
+      steps: z.array(z.string()),
+      triggers: z.array(z.string()).optional(),
+      notes: z.string().optional()
+    }),
+    (input) => workflow({
       task: input.task,
       steps: input.steps,
       triggers: input.triggers,
       notes: input.notes
     })
-  },
-  quirk: {
-    toFragment: (input) => quirk({
+  ),
+  quirk: builtInEntry(
+    z.object({ issue: z.string(), workaround: z.string() }),
+    (input) => quirk({
       issue: input.issue,
       workaround: input.workaround
     })
-  },
-  styleGuide: {
-    toFragment: (input) => styleGuide({
+  ),
+  styleGuide: builtInEntry(
+    z.object({
+      prefer: z.string(),
+      never: z.string().optional(),
+      always: z.string().optional()
+    }),
+    (input) => styleGuide({
       prefer: input.prefer,
       never: input.never,
       always: input.always
     })
-  },
-  analogy: {
-    toFragment: (input) => analogy({
+  ),
+  analogy: builtInEntry(
+    z.object({
+      concepts: z.array(z.string()),
+      relationship: z.string(),
+      insight: z.string().optional(),
+      therefore: z.string().optional(),
+      pitfall: z.string().optional()
+    }),
+    (input) => analogy({
       concepts: input.concepts,
       relationship: input.relationship,
       insight: input.insight,
       therefore: input.therefore,
       pitfall: input.pitfall
     })
-  },
-  glossary: {
-    toFragment: (input) => glossary(input.entries)
-  },
-  role: {
-    toFragment: (input) => role(input.content)
-  },
-  principle: {
-    toFragment: (input, options) => principle({
+  ),
+  glossary: builtInEntry(
+    z.object({ entries: z.record(z.string(), z.string()) }),
+    (input) => glossary(input.entries)
+  ),
+  role: builtInEntry(
+    z.object({ content: z.string() }),
+    (input) => role(input.content)
+  ),
+  principle: builtInEntry(
+    z.object({
+      title: z.string(),
+      description: z.string(),
+      policies: nestedPolicies
+    }),
+    (input, options) => principle({
       title: input.title,
       description: input.description,
       policies: input.policies?.map((item) => toFragmentData(item, options))
     })
-  },
-  policy: {
-    toFragment: (input, options) => policy({
+  ),
+  policy: builtInEntry(
+    z.object({
+      rule: z.string(),
+      before: z.string().optional(),
+      reason: z.string().optional(),
+      policies: nestedPolicies
+    }),
+    (input, options) => policy({
       rule: input.rule,
       before: input.before,
       reason: input.reason,
       policies: input.policies?.map((item) => toFragmentData(item, options))
     })
-  },
-  identity: {
-    toFragment: (input) => identity({
+  ),
+  identity: builtInEntry(
+    z.object({ name: z.string().optional(), role: z.string().optional() }),
+    (input) => identity({
       name: input.name,
       role: input.role
     })
-  },
-  persona: {
-    toFragment: (input) => persona({
+  ),
+  persona: builtInEntry(
+    z.object({
+      name: z.string(),
+      role: z.string().optional(),
+      objective: z.string().optional(),
+      tone: z.string().optional()
+    }),
+    (input) => persona({
       name: input.name,
       role: input.role,
       objective: input.objective,
       tone: input.tone
     })
-  },
-  alias: {
-    toFragment: (input) => alias(input.term, input.meaning)
-  },
-  preference: {
-    toFragment: (input) => preference(input.aspect, input.value)
-  },
-  correction: {
-    toFragment: (input) => correction(input.subject, input.clarification)
-  }
+  ),
+  alias: builtInEntry(
+    z.object({ term: z.string(), meaning: z.string() }),
+    (input) => alias(input.term, input.meaning)
+  ),
+  preference: builtInEntry(
+    z.object({ aspect: z.string(), value: z.string() }),
+    (input) => preference(input.aspect, input.value)
+  ),
+  correction: builtInEntry(
+    z.object({ subject: z.string(), clarification: z.string() }),
+    (input) => correction(input.subject, input.clarification)
+  )
 };
+function isBuiltInSerializedType(type) {
+  return Object.hasOwn(builtInSerializedRegistry, type);
+}
 var messageLikeTypes = /* @__PURE__ */ new Set(["user", "assistant", "message"]);
 function findCustomSerializedFragment(fragment2, options) {
   if (!options?.registry) {
@@ -720,7 +826,7 @@ function toFragment(input, options) {
       "Message fragments are not supported by serialized fragment conversion"
     );
   }
-  const entry = options?.registry?.[input.type] ?? builtInSerializedRegistry[input.type];
+  const entry = options?.registry?.[input.type] ?? (isBuiltInSerializedType(input.type) ? builtInSerializedRegistry[input.type] : void 0);
   if (!entry) {
     throw new Error(`Unsupported serialized fragment type: ${input.type}`);
   }
@@ -745,7 +851,7 @@ function fromFragment(fragment2, options) {
     }
     return encoded;
   }
-  if (!builtInSerializedRegistry[fragment2.name]) {
+  if (!isBuiltInSerializedType(fragment2.name)) {
     throw new Error(`Unsupported fragment name: ${fragment2.name}`);
   }
   throw new Error(`Fragment "${fragment2.name}" is missing codec`);
@@ -753,6 +859,7 @@ function fromFragment(fragment2, options) {
 
 // packages/context/src/lib/estimate.ts
 import { encode } from "gpt-tokenizer";
+import { z as z2 } from "zod";
 var defaultTokenizer = {
   encode(text) {
     return encode(text);
@@ -761,6 +868,36 @@ var defaultTokenizer = {
     return encode(text).length;
   }
 };
+var modelCostSchema = z2.object({
+  input: z2.number(),
+  output: z2.number(),
+  cache_read: z2.number().optional(),
+  cache_write: z2.number().optional(),
+  reasoning: z2.number().optional()
+});
+var modelsDevResponseSchema = z2.record(
+  z2.string(),
+  z2.object({
+    models: z2.record(
+      z2.string(),
+      z2.object({
+        id: z2.string(),
+        name: z2.string(),
+        family: z2.string().optional(),
+        cost: modelCostSchema.optional(),
+        limit: z2.object({ context: z2.number(), output: z2.number() })
+      })
+    )
+  })
+);
+function inputPricePerMillion(model) {
+  if (!model.cost) {
+    throw new Error(
+      `Model "${model.provider}:${model.id}" has no pricing data on models.dev`
+    );
+  }
+  return model.cost.input;
+}
 var ModelsRegistry = class {
   #cache = /* @__PURE__ */ new Map();
   #loaded = false;
@@ -775,7 +912,7 @@ var ModelsRegistry = class {
     if (!response.ok) {
       throw new Error(`Failed to fetch models: ${response.statusText}`);
     }
-    const data = await response.json();
+    const data = modelsDevResponseSchema.parse(await response.json());
     for (const [providerId, provider] of Object.entries(data)) {
       for (const [modelId, model] of Object.entries(provider.models)) {
         const info = {
@@ -828,14 +965,9 @@ var ModelsRegistry = class {
    * Get the appropriate tokenizer for a model
    */
   getTokenizer(modelId) {
-    const model = this.get(modelId);
-    if (model) {
-      const familyTokenizer = this.#tokenizers.get(model.family);
-      if (familyTokenizer) {
-        return familyTokenizer;
-      }
-    }
-    return this.#defaultTokenizer;
+    const family = this.get(modelId)?.family;
+    const familyTokenizer = family === void 0 ? void 0 : this.#tokenizers.get(family);
+    return familyTokenizer ?? this.#defaultTokenizer;
   }
   /**
    * Estimate token count and cost for given text and model
@@ -849,9 +981,10 @@ var ModelsRegistry = class {
         `Model "${modelId}" not found. Call load() first or check model ID.`
       );
     }
+    const inputPrice = inputPricePerMillion(model);
     const tokenizer = this.getTokenizer(modelId);
     const tokens = tokenizer.count(input);
-    const cost = tokens / 1e6 * model.cost.input;
+    const cost = tokens / 1e6 * inputPrice;
     return {
       model: model.id,
       provider: model.provider,
@@ -866,12 +999,9 @@ var ModelsRegistry = class {
     };
   }
 };
-var _registry = null;
+var sharedRegistry = new ModelsRegistry();
 function getModelsRegistry() {
-  if (!_registry) {
-    _registry = new ModelsRegistry();
-  }
-  return _registry;
+  return sharedRegistry;
 }
 async function estimate(modelId, renderer, ...fragments) {
   const registry = getModelsRegistry();
@@ -883,13 +1013,14 @@ async function estimate(modelId, renderer, ...fragments) {
       `Model "${modelId}" not found. Call load() first or check model ID.`
     );
   }
+  const inputPrice = inputPricePerMillion(model);
   const tokenizer = registry.getTokenizer(modelId);
   const totalTokens = tokenizer.count(input);
-  const totalCost = totalTokens / 1e6 * model.cost.input;
+  const totalCost = totalTokens / 1e6 * inputPrice;
   const fragmentEstimates = fragments.map((fragment2) => {
     const rendered = renderer.render([fragment2]);
     const tokens = tokenizer.count(rendered);
-    const cost = tokens / 1e6 * model.cost.input;
+    const cost = tokens / 1e6 * inputPrice;
     return {
       id: fragment2.id,
       name: fragment2.name,
@@ -2427,8 +2558,10 @@ export {
   guardrail,
   hint,
   identity,
+  inputPricePerMillion,
   isConditionalReminder,
   isFragment,
+  isFragmentData,
   isFragmentObject,
   isMessageFragment,
   isRecord,