@finalai/agent-definition 0.1.0

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

@@ -0,0 +1,472 @@
+import {
+  childPath,
+  dynamicEventsOf,
+  error,
+  isDynamicSentinel,
+  isEnvironmentLike,
+  isOpenRequestLike,
+  lowerConnection,
+  lowerEnvironment,
+  lowerInstructions,
+  lowerSkill,
+  lowerTool,
+  note,
+  sandboxProviderNameOf,
+  toJson
+} from "./chunk-ZDLVA6XF.ts";
+import {
+  AGENT_DYNAMIC_PREFIX,
+  namedExportName
+} from "./chunk-NMYHO2QN.ts";
+import {
+  authoredKindOf,
+  pendingEntries,
+  pendingExportName
+} from "./chunk-XHKPWT3G.ts";
+import {
+  entriesOf,
+  fieldOf,
+  isCallable,
+  isObjectLike,
+  isPlainObject,
+  isPromiseLike,
+  isString,
+  messageOf,
+  stringOrNull
+} from "./chunk-JIPNTA56.ts";
+import {
+  array,
+  string
+} from "./chunk-HGW4YHAY.ts";
+
+// src/runtime/describe.ts
+var describeDynamic = (value) => {
+  const provider = fieldOf(value, "provider");
+  let hint = null;
+  if (provider != null) {
+    const kind = fieldOf(provider, "kind");
+    const ref = fieldOf(provider, "providerRef");
+    const issues = [];
+    if ((kind === "package" || kind === "bundle") && provider != null) {
+      hint = { ref: toJson(provider, { path: "provider", issues }), name: null };
+    } else if (ref != null) {
+      hint = { ref: toJson(ref, { path: "provider", issues }), name: null };
+    } else {
+      hint = {
+        ref: null,
+        name: stringOrNull(fieldOf(provider, "name")) ?? stringOrNull(fieldOf(fieldOf(provider, "definition"), "name"))
+      };
+    }
+  }
+  return {
+    type: "dynamic",
+    events: dynamicEventsOf(value),
+    description: stringOrNull(fieldOf(value, "description")),
+    preview: stringOrNull(fieldOf(value, "preview")),
+    provider: hint
+  };
+};
+var collectAgentDynamics = (agent) => {
+  const found = [];
+  const walk = (value, path, depth) => {
+    if (depth > 32) return;
+    if (isDynamicSentinel(value)) {
+      found.push({ path, value });
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => walk(item, childPath(path, index), depth + 1));
+      return;
+    }
+    if (isPlainObject(value) || authoredKindOf(value) != null) {
+      for (const [key, item] of entriesOf(value)) walk(item, childPath(path, key), depth + 1);
+    }
+  };
+  walk(fieldOf(fieldOf(agent, "harness"), "config"), "harness.config", 0);
+  return found;
+};
+var dynamicSlot = (value, path) => {
+  const described = describeDynamic(value);
+  const slot = { resolver: `${AGENT_DYNAMIC_PREFIX}${path}`, events: described.events };
+  if (described.description != null) slot["description"] = described.description;
+  if (described.preview != null) slot["preview"] = described.preview;
+  return { $dynamic: slot };
+};
+var isDefinedHarnessLike = (value) => isCallable(value) && isCallable(fieldOf(value, "describe")) && isCallable(fieldOf(value, "open"));
+var KNOWN_AGENT_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "avatarUrl",
+  "harness",
+  "tools",
+  "toolPolicy",
+  "secrets",
+  "channels"
+]);
+var HARNESS_CONFIG_FIELDS = /* @__PURE__ */ new Set([
+  "model",
+  "reasoning",
+  "credentials",
+  "permissions",
+  "permissionMode",
+  "instructions",
+  "skills",
+  "system",
+  "temperature",
+  "providerOptions",
+  "maxSteps",
+  "stopWhen"
+]);
+var unknownAgentField = (key) => {
+  if (HARNESS_CONFIG_FIELDS.has(key))
+    return `agent.ts field ${key} belongs in harness config (harness: serverlessPi({ ${key}: ... }))`;
+  if (key === "defaultTools")
+    return "agent.ts field defaultTools is not supported: base tools are declared with tools: baseTools({ ... }) and are off by default";
+  if (key === "subagents" || key === "memory") return `agent.ts field ${key} is not supported yet`;
+  return `agent.ts field ${key} is not an agent field (name, description, avatarUrl, harness, tools, toolPolicy, secrets, channels)`;
+};
+var describeHarness = (harness, ctx, issues) => {
+  if (harness == null) return null;
+  const ref = fieldOf(harness, "harness");
+  if (!isObjectLike(ref)) {
+    issues.push(error("agent.ts harness must be a harness binding, e.g. serverlessPi({ ... })"));
+    return null;
+  }
+  let refJson = toJson(ref, { path: "harness.harness", issues });
+  if (fieldOf(ref, "kind") === "bundle" && fieldOf(ref, "export") === "<pending>") {
+    const candidates = ctx.entries.flatMap(
+      (entry) => Object.entries(entry.namespace).filter(([, value]) => isDefinedHarnessLike(value)).map(([name]) => namedExportName(entry.layout.base, name))
+    );
+    if (candidates.length === 1 && candidates[0] != null)
+      refJson = { kind: "bundle", export: candidates[0] };
+    else
+      issues.push(
+        error(
+          "the custom harness must come from defineHarness in @finalai/agents, or be exported once"
+        )
+      );
+  }
+  const config = toJson(fieldOf(harness, "config") ?? {}, {
+    path: "harness.config",
+    issues,
+    visit: (value, path) => isDynamicSentinel(value) ? dynamicSlot(value, path) : void 0
+  });
+  return { harness: refJson, config };
+};
+var describeBaseTools = (tools, ctx, issues) => {
+  if (tools == null) return null;
+  if (authoredKindOf(tools) !== "base-tools" /* BaseTools */) {
+    issues.push(error("agent.ts tools must be baseTools({ shell: target, files: target, ... })"));
+    return null;
+  }
+  const base = fieldOf(tools, "base");
+  const out = {};
+  const host = [];
+  if (!isPlainObject(base)) return { targets: out, host };
+  for (const [capability, target] of Object.entries(base)) {
+    if (target == null) continue;
+    if (authoredKindOf(target) === "harness-host" /* HarnessHost */) {
+      host.push(capability);
+      continue;
+    }
+    if (isString(target)) {
+      out[capability] = target;
+      continue;
+    }
+    const name = ctx.sandboxIdentity.get(target);
+    if (name == null) {
+      issues.push(
+        error(
+          `baseTools ${capability} is bound to a value that is not a sandbox target exported from sandbox.ts`
+        )
+      );
+      continue;
+    }
+    out[capability] = name;
+  }
+  return { targets: out, host };
+};
+var describeSecrets = (value, issues) => {
+  if (value == null) return null;
+  const parsed = array(string().min(1)).safeParse(value);
+  if (parsed.success) return parsed.data;
+  issues.push(error("agent.ts secrets must be a list of secret names"));
+  return null;
+};
+var describeAgent = (value, ctx, issues) => {
+  if (value == null) return null;
+  if (!isPlainObject(value)) {
+    issues.push(error("agent.ts must export defineAgent({ ... }) as its default export"));
+    return null;
+  }
+  for (const key of Object.keys(value)) {
+    if (!KNOWN_AGENT_FIELDS.has(key)) issues.push(error(unknownAgentField(key)));
+  }
+  const toolPolicyRaw = value["toolPolicy"];
+  let toolPolicy = null;
+  if (isPlainObject(toolPolicyRaw)) {
+    toolPolicy = {};
+    for (const [key, policy] of Object.entries(toolPolicyRaw)) {
+      if (policy === "allow" || policy === "ask") toolPolicy[key] = policy;
+      else issues.push(error(`agent.ts toolPolicy.${key} must be 'allow' or 'ask'`));
+    }
+  }
+  const channelsRaw = value["channels"];
+  let channels = null;
+  if (Array.isArray(channelsRaw)) {
+    channels = channelsRaw.map((binding, index) => ({
+      key: stringOrNull(fieldOf(binding, "key")),
+      channel: toJson(fieldOf(binding, "channel") ?? null, {
+        path: `channels[${index}].channel`,
+        issues
+      }),
+      config: toJson(fieldOf(binding, "config") ?? {}, {
+        path: `channels[${index}].config`,
+        issues
+      })
+    }));
+  }
+  const baseToolsDescription = describeBaseTools(value["tools"], ctx, issues);
+  return {
+    type: "agent",
+    name: stringOrNull(value["name"]),
+    description: stringOrNull(value["description"]),
+    avatarUrl: stringOrNull(value["avatarUrl"]),
+    harness: describeHarness(value["harness"], ctx, issues),
+    tools: baseToolsDescription?.targets ?? null,
+    hostTools: baseToolsDescription?.host ?? null,
+    toolPolicy,
+    secrets: describeSecrets(value["secrets"], issues),
+    channels
+  };
+};
+var probeSelector = (selector, issues) => {
+  if (!isCallable(selector)) return null;
+  try {
+    const result = selector({
+      session: null,
+      secrets: { get: async () => null },
+      open: async () => {
+        throw new Error("sandboxes do not open while compiling");
+      }
+    });
+    if (isEnvironmentLike(result) || isOpenRequestLike(result)) return result;
+    if (isPromiseLike(result)) Promise.resolve(result).catch(() => void 0);
+    return null;
+  } catch (cause) {
+    issues.push(
+      error(
+        `sandbox.ts selector failed during compilation: ${String(cause)}; export its environment when it needs session context`
+      )
+    );
+    return null;
+  }
+};
+var describeSandbox = (namespace, issues) => {
+  const targets = {};
+  const providers = {};
+  const describeTarget = (value, exportName, path) => {
+    if (isDynamicSentinel(value))
+      return { exportName, environment: null, dynamic: describeDynamic(value) };
+    if (isEnvironmentLike(value) || isOpenRequestLike(value)) {
+      return { exportName, environment: lowerEnvironment(value, path, issues), dynamic: null };
+    }
+    return null;
+  };
+  for (const [name, value] of Object.entries(namespace)) {
+    if (name === "default") continue;
+    const exportName = namedExportName("sandbox", name);
+    const providerName = sandboxProviderNameOf(value);
+    if (providerName != null) {
+      providers[exportName] = providerName;
+      continue;
+    }
+    const target = describeTarget(value, exportName, `sandbox.ts ${name}`);
+    if (target != null) targets[name] = target;
+  }
+  const named = Object.keys(targets);
+  const fallback = describeTarget(namespace["default"], "sandbox", "sandbox.ts default export");
+  const selector = authoredKindOf(namespace["default"]) === "sandbox-selector" /* SandboxSelector */;
+  if (fallback != null) targets["default"] = fallback;
+  else if (namespace["default"] != null && !selector) {
+    issues.push(
+      error(
+        "sandbox.ts default export must be defineSandbox(selector), an environment, or defineDynamic(...)"
+      )
+    );
+  }
+  if (selector && named.length === 0 && fallback == null) {
+    const opened = probeSelector(namespace["default"], issues);
+    if (opened != null) {
+      targets["default"] = {
+        exportName: "sandbox",
+        environment: lowerEnvironment(opened, "sandbox.ts default export", issues),
+        dynamic: null
+      };
+    }
+  }
+  let defaultTarget = null;
+  if (targets["default"] != null) defaultTarget = "default";
+  else if (named.length === 1) defaultTarget = named[0] ?? null;
+  if (selector && defaultTarget == null) {
+    issues.push(
+      error(
+        named.length === 0 ? "sandbox.ts default export opens a sandbox but no environment is exported; export the environment it opens (export const computer = computer({ ... }))" : "sandbox.ts default export opens a sandbox but several environments are exported; the selector needs exactly one"
+      )
+    );
+  }
+  return { type: "sandbox", targets, providers, selector, defaultTarget };
+};
+var sandboxIdentityOf = (namespace, sandbox) => {
+  const identity = /* @__PURE__ */ new Map();
+  if (namespace == null || sandbox == null) return identity;
+  for (const [name, value] of Object.entries(namespace)) {
+    if (name === "default") {
+      if (sandbox.defaultTarget != null) identity.set(value, sandbox.defaultTarget);
+    } else if (sandbox.targets[name] != null) identity.set(value, name);
+  }
+  return identity;
+};
+var describeModuleValue = (entry, ctx, sandbox, issues) => {
+  const { layout, namespace } = entry;
+  const value = namespace["default"];
+  switch (layout.slot) {
+    case "agent" /* Agent */:
+      return describeAgent(value, ctx, issues);
+    case "sandbox" /* Sandbox */:
+      return sandbox;
+    case "instructions" /* Instructions */: {
+      if (isDynamicSentinel(value)) return describeDynamic(value);
+      const fragment = lowerInstructions(value, null);
+      if (fragment == null) {
+        issues.push(
+          error(
+            `${layout.path} must export defineInstructions({ content, role }) or defineDynamic(...)`
+          )
+        );
+        return null;
+      }
+      return { type: "instructions", role: fragment.role, content: fragment.content };
+    }
+    case "skill" /* Skill */: {
+      if (isDynamicSentinel(value)) return describeDynamic(value);
+      const lowered = lowerSkill({ key: layout.key, value });
+      issues.push(...lowered.issues);
+      return { type: "skill", skill: toJson(lowered.skill, { path: layout.path, issues }) };
+    }
+    case "tool" /* Tool */: {
+      if (isDynamicSentinel(value)) return describeDynamic(value);
+      const lowered = lowerTool({ name: layout.key, exportName: layout.base, value });
+      issues.push(...lowered.issues);
+      return {
+        type: "tool",
+        descriptor: toJson(lowered.descriptor, { path: layout.path, issues }),
+        approval: lowered.approval
+      };
+    }
+    case "connection" /* Connection */: {
+      if (isDynamicSentinel(value)) return describeDynamic(value);
+      const lowered = lowerConnection({ key: layout.key, exportName: layout.base, value });
+      issues.push(...lowered.issues);
+      return {
+        type: "connection",
+        binding: toJson(lowered.binding, { path: layout.path, issues })
+      };
+    }
+    case "schedule" /* Schedule */:
+      return {
+        type: "schedule",
+        cron: stringOrNull(fieldOf(value, "cron")),
+        markdown: stringOrNull(fieldOf(value, "markdown")),
+        timezone: stringOrNull(fieldOf(value, "timezone")),
+        target: stringOrNull(fieldOf(value, "target"))
+      };
+    case "hook" /* Hook */: {
+      const events = fieldOf(value, "events");
+      return {
+        type: "hook",
+        keys: entriesOf(events).map(([key]) => key)
+      };
+    }
+    case "channel" /* Channel */: {
+      const routes = fieldOf(value, "routes");
+      return {
+        type: "channel",
+        disabled: fieldOf(value, "disabled") === true,
+        installed: toJson(fieldOf(value, "installed") ?? null, {
+          path: `${layout.path} installed`,
+          issues
+        }),
+        routes: Array.isArray(routes) ? routes.map((route) => ({
+          method: String(fieldOf(route, "method")),
+          path: String(fieldOf(route, "path"))
+        })) : [],
+        turnPolicy: stringOrNull(fieldOf(value, "turnPolicy")),
+        config: toJson(fieldOf(value, "config") ?? {}, { path: `${layout.path} config`, issues })
+      };
+    }
+  }
+};
+var describeBundle = (entries, synthesized) => {
+  const sandboxEntry = entries.find((entry) => entry.layout.slot === "sandbox" /* Sandbox */) ?? null;
+  const sandboxIssues = [];
+  let sandbox = null;
+  if (sandboxEntry != null) {
+    try {
+      sandbox = describeSandbox(sandboxEntry.namespace, sandboxIssues);
+    } catch (cause) {
+      sandboxIssues.push(error(`sandbox.ts could not be described: ${messageOf(cause)}`));
+    }
+  }
+  const ctx = {
+    entries,
+    sandboxIdentity: sandboxIdentityOf(sandboxEntry?.namespace ?? null, sandbox)
+  };
+  const modules = entries.map((entry) => {
+    const issues = entry.layout.slot === "sandbox" /* Sandbox */ ? sandboxIssues : [];
+    const hasDefault = "default" in entry.namespace && entry.namespace["default"] !== void 0;
+    let value = null;
+    if (hasDefault || entry.layout.slot === "sandbox" /* Sandbox */) {
+      try {
+        value = describeModuleValue(entry, ctx, sandbox, issues);
+      } catch (cause) {
+        issues.push(error(`${entry.layout.path} could not be described: ${messageOf(cause)}`));
+      }
+    } else if (entry.layout.slot !== "agent" /* Agent */) {
+      issues.push(note(`${entry.layout.path} has no default export; treated as a helper module`));
+    }
+    return {
+      base: entry.layout.base,
+      path: entry.layout.path,
+      slot: entry.layout.slot,
+      key: entry.layout.key,
+      hasDefault,
+      issues,
+      value
+    };
+  });
+  return { modules, synthesized };
+};
+var synthesizedExports = (entries) => {
+  const out = [];
+  for (const entry of entries) {
+    if (entry.layout.slot !== "agent" /* Agent */) continue;
+    for (const found of collectAgentDynamics(entry.namespace["default"])) {
+      out.push({ name: `${AGENT_DYNAMIC_PREFIX}${found.path}`, value: found.value });
+    }
+  }
+  for (const pending of pendingEntries())
+    out.push({ name: pendingExportName(pending.index), value: pending.value });
+  return out;
+};
+var needsCombinedMcpServers = (entries) => entries.some(
+  (entry) => (entry.layout.slot === "tool" /* Tool */ || entry.layout.slot === "connection" /* Connection */) && isDynamicSentinel(entry.namespace["default"])
+);
+
+export {
+  describeDynamic,
+  collectAgentDynamics,
+  describeBundle,
+  synthesizedExports,
+  needsCombinedMcpServers
+};

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

@@ -0,0 +1,25 @@
+// src/runtime/layout.ts
+var SlotKind = /* @__PURE__ */ ((SlotKind2) => {
+  SlotKind2["Agent"] = "agent";
+  SlotKind2["Instructions"] = "instructions";
+  SlotKind2["Skill"] = "skill";
+  SlotKind2["Tool"] = "tool";
+  SlotKind2["Connection"] = "connection";
+  SlotKind2["Schedule"] = "schedule";
+  SlotKind2["Hook"] = "hook";
+  SlotKind2["Channel"] = "channel";
+  SlotKind2["Sandbox"] = "sandbox";
+  return SlotKind2;
+})(SlotKind || {});
+var AGENT_DYNAMIC_PREFIX = "agent:";
+var COMBINED_MCP_SERVERS_EXPORT = "final:mcpServers";
+var AUTHORED_SERVER_KEY = "authored";
+var namedExportName = (base, name) => name === "default" ? base : `${base}#${name}`;
+
+export {
+  SlotKind,
+  AGENT_DYNAMIC_PREFIX,
+  COMBINED_MCP_SERVERS_EXPORT,
+  AUTHORED_SERVER_KEY,
+  namedExportName
+};

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

@@ -0,0 +1,28 @@
+import {
+  credentials
+} from "./chunk-HNPUTP35.ts";
+import {
+  DynamicEvent
+} from "./chunk-SKTNMUO7.ts";
+import {
+  isAuthored,
+  registerPending
+} from "./chunk-XHKPWT3G.ts";
+
+// src/authoring/credentials.ts
+var DYNAMIC_EVENTS = Object.values(DynamicEvent);
+var eventsOf = (sentinel) => DYNAMIC_EVENTS.filter((event) => sentinel.events[event] != null);
+var isSentinel = (value) => isAuthored(value, "dynamic" /* Dynamic */);
+var custom = (resolver) => {
+  if (!isSentinel(resolver)) return credentials.custom(resolver);
+  const events = eventsOf(resolver);
+  return credentials.custom({
+    resolverExport: registerPending(resolver),
+    events: events.length === 0 ? ["session.started" /* SessionStarted */] : events
+  });
+};
+var credentials2 = { ...credentials, custom };
+
+export {
+  credentials2 as credentials
+};