@finalai/agent-definition 0.1.0

package/dist/compiler-assets/chunk-EVQIK62B.ts

@@ -0,0 +1,188 @@
+import {
+  formatProviderRef,
+  instructionFragmentSchema,
+  mcpServerBindingSchema,
+  providerRefSchema,
+  resolvedAgentManifestSchema,
+  sandboxBindingSchema,
+  skillBundleSchema
+} from "./chunk-OWC6SFFF.ts";
+import {
+  jsonObjectSchema,
+  jsonValueSchema
+} from "./chunk-7QP2CKPI.ts";
+import {
+  findDynamicSlots,
+  isDynamicSlot
+} from "./chunk-SKTNMUO7.ts";
+import {
+  _null,
+  array,
+  looseObject,
+  number,
+  record,
+  string
+} from "./chunk-HGW4YHAY.ts";
+
+// src/resolve.ts
+var SlotValueKind = /* @__PURE__ */ ((SlotValueKind2) => {
+  SlotValueKind2["InstructionFragment"] = "instruction-fragment";
+  SlotValueKind2["SkillBundle"] = "skill-bundle";
+  SlotValueKind2["McpServers"] = "mcp-servers";
+  SlotValueKind2["Sandboxes"] = "sandboxes";
+  SlotValueKind2["SandboxEnvironment"] = "sandbox-environment";
+  SlotValueKind2["Opaque"] = "opaque";
+  return SlotValueKind2;
+})(SlotValueKind || {});
+var slotKindOf = (path) => {
+  if (/^harness\.config\.instructions\[\d+\]$/.test(path)) return "instruction-fragment" /* InstructionFragment */;
+  if (/^harness\.config\.skills\[\d+\]$/.test(path)) return "skill-bundle" /* SkillBundle */;
+  if (path === "mcpServers") return "mcp-servers" /* McpServers */;
+  if (path === "sandboxes") return "sandboxes" /* Sandboxes */;
+  if (/^sandboxes\.[^.]+\.environment$/.test(path)) return "sandbox-environment" /* SandboxEnvironment */;
+  return "opaque" /* Opaque */;
+};
+var resolvedSandboxesSchema = record(
+  string(),
+  sandboxBindingSchema.extend({ environment: jsonValueSchema })
+);
+var issueText = (error) => error.issues.map((issue) => `${issue.path.join(".") || "value"}: ${issue.message}`).join("; ");
+var invalid = (path, detail) => new Error(`dynamic slot ${path} resolved to an invalid value: ${detail}`);
+var parseAs = (schema, value, path) => {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) throw invalid(path, issueText(parsed.error));
+  return jsonValueSchema.parse(parsed.data);
+};
+var isRecord = (value) => jsonObjectSchema.safeParse(value).success;
+var roleless = looseObject({ role: _null().optional() });
+var environmentResultSchema = looseObject({
+  providerName: string(),
+  providerRef: jsonValueSchema.optional(),
+  options: jsonValueSchema.optional(),
+  openOptions: jsonValueSchema.optional()
+});
+var validateSlotValue = (path, value, manifest) => {
+  if (value == null) return null;
+  switch (slotKindOf(path)) {
+    case "instruction-fragment" /* InstructionFragment */: {
+      if (isRecord(value) && roleless.safeParse(value).success) {
+        return parseAs(instructionFragmentSchema, { ...value, role: "system" }, path);
+      }
+      return parseAs(instructionFragmentSchema, value, path);
+    }
+    case "skill-bundle" /* SkillBundle */:
+      return Array.isArray(value) ? parseAs(array(skillBundleSchema), value, path) : parseAs(skillBundleSchema, value, path);
+    case "mcp-servers" /* McpServers */:
+      return parseAs(array(mcpServerBindingSchema), value, path);
+    case "sandboxes" /* Sandboxes */:
+      return parseAs(resolvedSandboxesSchema, value, path);
+    case "sandbox-environment" /* SandboxEnvironment */:
+      if (manifest != null) checkEnvironmentProvider(manifest, path, value);
+      const environment = environmentResultSchema.safeParse(value);
+      if (environment.success && environment.data.openOptions != null)
+        parseAs(
+          sandboxBindingSchema.pick({ access: true, attach: true }).partial(),
+          environment.data.openOptions,
+          path
+        );
+      return environment.success ? environment.data.options ?? null : value;
+    case "opaque" /* Opaque */:
+      return value;
+  }
+};
+var childPath = (parent, key) => {
+  if (number().safeParse(key).success) return `${parent}[${key}]`;
+  return parent.length === 0 ? `${key}` : `${parent}.${key}`;
+};
+var splice = (value, values, path) => {
+  if (isDynamicSlot(value)) return values[path] ?? null;
+  if (Array.isArray(value)) {
+    const out = [];
+    value.forEach((item, index) => {
+      const itemPath = childPath(path, index);
+      if (isDynamicSlot(item)) {
+        const resolved = values[itemPath];
+        if (resolved == null) return;
+        if (Array.isArray(resolved) && slotKindOf(itemPath) === "skill-bundle" /* SkillBundle */)
+          out.push(...resolved);
+        else out.push(resolved);
+        return;
+      }
+      out.push(splice(item, values, itemPath));
+    });
+    return out;
+  }
+  if (isRecord(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      const itemPath = childPath(path, key);
+      if (isDynamicSlot(item) && values[itemPath] == null && !KEEP_NULL.test(itemPath)) continue;
+      out[key] = splice(item, values, itemPath);
+    }
+    return out;
+  }
+  return value;
+};
+var KEEP_NULL = /^(sandboxes\.[^.]+\.environment)$/;
+var FIELD_DEFAULTS = /* @__PURE__ */ new Map([
+  ["mcpServers", []],
+  ["sandboxes", {}],
+  ["harness.config", {}]
+]);
+var checkEnvironmentProvider = (manifest, path, value) => {
+  if (slotKindOf(path) !== "sandbox-environment" /* SandboxEnvironment */ || value == null) return;
+  const returned = environmentResultSchema.safeParse(value);
+  if (!returned.success) return;
+  const target = path.slice("sandboxes.".length, -".environment".length);
+  const sandboxes = record(string(), sandboxBindingSchema).safeParse(manifest.sandboxes);
+  const provider = sandboxes.success ? sandboxes.data[target]?.provider : void 0;
+  if (provider == null) return;
+  const returnedRef = providerRefSchema.safeParse(returned.data.providerRef);
+  const mismatch = returnedRef.success ? formatProviderRef(returnedRef.data) !== formatProviderRef(provider) : (
+    // A bundle provider's environment carries only its name; installed ones are named for their specifier.
+    provider.kind === "package" /* Package */
+  );
+  if (mismatch) {
+    throw invalid(
+      path,
+      `returned a ${returned.data.providerName} environment for a ${formatProviderRef(provider)} target`
+    );
+  }
+};
+var resolveManifestDetailed = async (args) => {
+  const manifestJson = jsonValueSchema.parse(args.manifest);
+  const slots = findDynamicSlots(manifestJson);
+  const values = {};
+  const normalized = {};
+  for (const found of slots) {
+    const subscribed = found.slot.$dynamic.events.includes(args.event);
+    const raw = subscribed ? await args.resolve(found.slot, found.path) : args.previous?.[found.path] ?? null;
+    if (subscribed) checkEnvironmentProvider(args.manifest, found.path, raw);
+    normalized[found.path] = validateSlotValue(found.path, raw) ?? FIELD_DEFAULTS.get(found.path) ?? null;
+    values[found.path] = slotKindOf(found.path) === "sandbox-environment" /* SandboxEnvironment */ ? raw : normalized[found.path] ?? null;
+  }
+  const spliced = splice(manifestJson, normalized, "");
+  const parsed = resolvedAgentManifestSchema.safeParse(spliced);
+  if (!parsed.success) throw new Error(`resolved manifest is invalid: ${issueText(parsed.error)}`);
+  const openOptionsSchema = sandboxBindingSchema.pick({ access: true, attach: true }).partial();
+  for (const [path, raw] of Object.entries(values)) {
+    if (slotKindOf(path) !== "sandbox-environment" /* SandboxEnvironment */) continue;
+    const environment = environmentResultSchema.safeParse(raw);
+    if (!environment.success || environment.data.openOptions == null) continue;
+    const options = openOptionsSchema.safeParse(environment.data.openOptions);
+    if (!options.success) throw invalid(path, issueText(options.error));
+    const target = path.slice("sandboxes.".length, -".environment".length);
+    const binding = parsed.data.sandboxes[target];
+    if (binding != null) parsed.data.sandboxes[target] = { ...binding, ...options.data };
+  }
+  return { manifest: parsed.data, values };
+};
+var resolveManifest = async (args) => (await resolveManifestDetailed(args)).manifest;
+
+export {
+  SlotValueKind,
+  slotKindOf,
+  validateSlotValue,
+  resolveManifestDetailed,
+  resolveManifest
+};