@finalai/agent-definition 0.1.0

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

@@ -0,0 +1,295 @@
+import {
+  jsonObjectSchema,
+  jsonSchemaSchema,
+  jsonValueSchema
+} from "./chunk-7QP2CKPI.ts";
+import {
+  DynamicEvent,
+  containsDynamicSlot,
+  maybeDynamic
+} from "./chunk-SKTNMUO7.ts";
+import {
+  array,
+  boolean,
+  discriminatedUnion,
+  literal,
+  nativeEnum,
+  object,
+  partialRecord,
+  record,
+  string,
+  union
+} from "./chunk-HGW4YHAY.ts";
+
+// ../agent-provider/src/provider-ref.ts
+var packageProviderRefSchema = object({
+  kind: literal("package" /* Package */),
+  specifier: string().min(1)
+});
+var bundleProviderRefSchema = object({
+  kind: literal("bundle" /* Bundle */),
+  export: string().min(1)
+});
+var providerRefSchema = discriminatedUnion("kind", [
+  packageProviderRefSchema,
+  bundleProviderRefSchema
+]);
+var packageRef = (specifier) => ({
+  kind: "package" /* Package */,
+  specifier
+});
+var bundleRef = (exportName) => ({
+  kind: "bundle" /* Bundle */,
+  export: exportName
+});
+var formatProviderRef = (ref) => ref.kind === "package" /* Package */ ? `package:${ref.specifier}` : `bundle:${ref.export}`;
+
+// ../agent-provider/src/manifest.ts
+var MANIFEST_VERSION = 2;
+var BaseCapability = /* @__PURE__ */ ((BaseCapability2) => {
+  BaseCapability2["Shell"] = "shell";
+  BaseCapability2["Files"] = "files";
+  BaseCapability2["Process"] = "process";
+  BaseCapability2["Ports"] = "ports";
+  BaseCapability2["Browser"] = "browser";
+  BaseCapability2["ComputerUse"] = "computerUse";
+  return BaseCapability2;
+})(BaseCapability || {});
+var ToolApproval = /* @__PURE__ */ ((ToolApproval2) => {
+  ToolApproval2["Allow"] = "allow";
+  ToolApproval2["Ask"] = "ask";
+  return ToolApproval2;
+})(ToolApproval || {});
+var SandboxAccess = /* @__PURE__ */ ((SandboxAccess2) => {
+  SandboxAccess2["Read"] = "read";
+  SandboxAccess2["Execute"] = "execute";
+  SandboxAccess2["Write"] = "write";
+  return SandboxAccess2;
+})(SandboxAccess || {});
+var SandboxAttach = /* @__PURE__ */ ((SandboxAttach2) => {
+  SandboxAttach2["Lazy"] = "lazy";
+  SandboxAttach2["OnPrompt"] = "on-prompt";
+  return SandboxAttach2;
+})(SandboxAttach || {});
+var McpServerBindingKind = /* @__PURE__ */ ((McpServerBindingKind2) => {
+  McpServerBindingKind2["Worker"] = "worker";
+  McpServerBindingKind2["Http"] = "http";
+  return McpServerBindingKind2;
+})(McpServerBindingKind || {});
+var ScheduleTarget = /* @__PURE__ */ ((ScheduleTarget2) => {
+  ScheduleTarget2["OwnerDirect"] = "owner-direct";
+  ScheduleTarget2["BoundConversation"] = "bound-conversation";
+  return ScheduleTarget2;
+})(ScheduleTarget || {});
+var identitySchema = object({
+  name: string().min(1).max(120),
+  description: string().max(2e3).nullable(),
+  avatarUrl: string().url().nullable()
+});
+var InputApprovalKind = /* @__PURE__ */ ((InputApprovalKind2) => {
+  InputApprovalKind2["Tool"] = "tool";
+  InputApprovalKind2["Connection"] = "connection";
+  return InputApprovalKind2;
+})(InputApprovalKind || {});
+var inputApprovalSchema = object({
+  kind: nativeEnum(InputApprovalKind),
+  export: string().min(1),
+  // Connection default when absent; otherwise tools.approval[policyKey].
+  policyKey: string().min(1).optional(),
+  dynamic: jsonObjectSchema.optional()
+});
+var toolDescriptorSchema = object({
+  name: string().min(1),
+  description: string(),
+  inputSchema: jsonSchemaSchema,
+  outputSchema: jsonSchemaSchema.optional(),
+  annotations: object({
+    title: string().optional(),
+    readOnlyHint: boolean().optional(),
+    destructiveHint: boolean().optional(),
+    idempotentHint: boolean().optional(),
+    openWorldHint: boolean().optional()
+  }).optional(),
+  // Bundle export implementing it ('tools/lookup_release_notes').
+  export: string().min(1).optional(),
+  // Boundary snapshot used to reconstruct dynamic tools after isolate eviction.
+  dynamic: jsonObjectSchema.optional(),
+  inputApproval: inputApprovalSchema.optional()
+});
+var mcpAuthSchema = union([
+  object({ secretKey: string().min(1), headerName: string().min(1).nullable() }),
+  // Resolved by the broker to a session-scoped grant (Final's own MCP server).
+  object({ kind: literal("final-session") })
+]);
+var toolApprovalsSchema = record(string(), nativeEnum(ToolApproval)).nullable();
+var workerMcpServerBindingSchema = object({
+  key: string().min(1),
+  kind: literal("worker" /* Worker */),
+  tools: array(toolDescriptorSchema),
+  approvals: toolApprovalsSchema
+});
+var httpMcpServerBindingSchema = object({
+  key: string().min(1),
+  kind: literal("http" /* Http */),
+  url: string().url(),
+  auth: mcpAuthSchema.nullable(),
+  headers: record(string(), string()).default({}),
+  // Null allows every tool the server lists, each with the default approval.
+  approvals: toolApprovalsSchema,
+  // Tools hidden even when `approvals` would expose them.
+  deny: array(string().min(1)).optional(),
+  // The authored resolver that produced this connection, for retained boundary values.
+  dynamicResolver: string().min(1).optional(),
+  inputApprovals: record(string(), inputApprovalSchema).optional()
+});
+var mcpServerBindingSchema = discriminatedUnion("kind", [
+  workerMcpServerBindingSchema,
+  httpMcpServerBindingSchema
+]);
+var sandboxBindingSchema = object({
+  provider: providerRefSchema,
+  // Provider-defined environment options (`computer`: a setup guide reference or
+  // inline guide plus start-time parameters). Validated by the provider.
+  environment: maybeDynamic(jsonValueSchema),
+  access: nativeEnum(SandboxAccess).default("write" /* Write */),
+  attach: nativeEnum(SandboxAttach).default("lazy" /* Lazy */)
+});
+var baseToolsSchema = object({
+  base: partialRecord(nativeEnum(BaseCapability), object({ target: string().min(1) })),
+  // Capabilities declared on the harness's own host with no sandbox target
+  // (`baseTools({ shell: harnessHost })`): only a harness that
+  // provides them natively (host-disableable, host-fixed) can serve them.
+  host: array(nativeEnum(BaseCapability)).optional()
+});
+var channelBindingSchema = object({
+  // Stable within the definition; publish maps it to a binding id.
+  key: string().min(1),
+  channel: providerRefSchema,
+  config: jsonObjectSchema.default({}),
+  source: string().optional()
+});
+var hookBindingSchema = object({
+  slug: string().min(1),
+  export: string().min(1),
+  events: array(string().min(1)).min(1)
+});
+var scheduleDefinitionSchema = object({
+  key: string().min(1),
+  cron: string().min(1),
+  timezone: string().min(1),
+  prompt: string().min(1),
+  target: nativeEnum(ScheduleTarget)
+});
+var bundleSchema = object({
+  // Absent on historical revisions: the host must inspect their resources.
+  hasPreparationFiles: boolean().optional(),
+  hash: string().min(1),
+  // Dynamic slot path → resolver export and events.
+  resolvers: record(
+    string(),
+    object({ export: string().min(1), events: array(nativeEnum(DynamicEvent)).min(1) })
+  )
+});
+var harnessBindingSchema = object({
+  harness: providerRefSchema,
+  // Validated against the harness's configSchema; may contain dynamic slots at
+  // any depth (an instruction fragment, the model).
+  config: maybeDynamic(jsonValueSchema)
+});
+var agentManifestSchema = object({
+  version: literal(MANIFEST_VERSION),
+  identity: identitySchema,
+  harness: harnessBindingSchema,
+  mcpServers: maybeDynamic(array(mcpServerBindingSchema)),
+  sandboxes: maybeDynamic(record(string(), sandboxBindingSchema)),
+  tools: baseToolsSchema,
+  toolPolicy: record(string(), nativeEnum(ToolApproval)),
+  // Organization secrets this agent may read, by name (`secrets.get`,
+  // MCP `secretKey`, `apiKey({ secret })`). Nothing else is readable;
+  // binding organization secrets requires an organization admin at publish.
+  secrets: array(string().min(1)).default([]),
+  channels: array(channelBindingSchema),
+  channelSources: record(string(), object({ path: string(), source: string(), disabled: boolean() })).optional(),
+  hooks: array(hookBindingSchema),
+  schedules: array(scheduleDefinitionSchema),
+  bundle: bundleSchema.nullable()
+});
+var resolvedAgentManifestSchema = agentManifestSchema.extend({
+  harness: object({ harness: providerRefSchema, config: jsonValueSchema }),
+  mcpServers: array(mcpServerBindingSchema),
+  sandboxes: record(string(), sandboxBindingSchema.extend({ environment: jsonValueSchema }))
+}).superRefine((manifest, ctx) => {
+  if (containsDynamicSlot(manifest)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "a resolved manifest must not contain dynamic slots"
+    });
+  }
+});
+var InstructionRole = /* @__PURE__ */ ((InstructionRole2) => {
+  InstructionRole2["System"] = "system";
+  InstructionRole2["User"] = "user";
+  return InstructionRole2;
+})(InstructionRole || {});
+var instructionFragmentSchema = object({
+  role: nativeEnum(InstructionRole),
+  content: string(),
+  // Source file, for the compatibility report and Build.
+  source: string().optional()
+});
+var skillFileSchema = object({ path: string().min(1), content: string() });
+var skillBundleSchema = object({
+  key: string().min(1),
+  description: string().optional(),
+  files: array(skillFileSchema)
+});
+var emptyManifest = (name) => ({
+  version: MANIFEST_VERSION,
+  identity: { name, description: null, avatarUrl: null },
+  harness: {
+    harness: packageRef("@finalai/final-agent-provider/harnesses/serverless-final"),
+    config: {}
+  },
+  mcpServers: [],
+  sandboxes: {},
+  tools: { base: {} },
+  toolPolicy: {},
+  secrets: [],
+  channels: [],
+  hooks: [],
+  schedules: [],
+  bundle: null
+});
+
+export {
+  providerRefSchema,
+  bundleRef,
+  formatProviderRef,
+  MANIFEST_VERSION,
+  BaseCapability,
+  ToolApproval,
+  SandboxAccess,
+  SandboxAttach,
+  McpServerBindingKind,
+  ScheduleTarget,
+  identitySchema,
+  toolDescriptorSchema,
+  mcpAuthSchema,
+  workerMcpServerBindingSchema,
+  httpMcpServerBindingSchema,
+  mcpServerBindingSchema,
+  sandboxBindingSchema,
+  baseToolsSchema,
+  channelBindingSchema,
+  hookBindingSchema,
+  scheduleDefinitionSchema,
+  bundleSchema,
+  harnessBindingSchema,
+  agentManifestSchema,
+  resolvedAgentManifestSchema,
+  InstructionRole,
+  instructionFragmentSchema,
+  skillFileSchema,
+  skillBundleSchema,
+  emptyManifest
+};

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

@@ -0,0 +1,59 @@
+import {
+  harnessDescriptionSchema
+} from "./chunk-JPY4L2UJ.ts";
+import {
+  bundleRef
+} from "./chunk-OWC6SFFF.ts";
+import {
+  registerPending
+} from "./chunk-XHKPWT3G.ts";
+
+// src/authoring/harness.ts
+var completeHarnessDescription = (authored) => {
+  const supports = {
+    observe: authored.supports?.observe ?? false,
+    resumeReplay: authored.supports?.resumeReplay ?? false,
+    fork: authored.supports?.fork ?? false,
+    authorMeta: authored.supports?.authorMeta ?? false
+  };
+  if (authored.supports?.nativeToolPolicy != null)
+    supports.nativeToolPolicy = authored.supports.nativeToolPolicy;
+  return harnessDescriptionSchema.parse({
+    ...authored,
+    acp: { transports: authored.acp.transports, mcp: authored.acp.mcp ?? [] },
+    baseTools: authored.baseTools ?? {},
+    consumes: authored.consumes ?? [],
+    inference: {
+      vendors: authored.inference?.vendors ?? [],
+      kinds: authored.inference?.kinds ?? ["harness-owned" /* HarnessOwned */],
+      delivery: authored.inference?.delivery ?? "at-open" /* AtOpen */
+    },
+    supports
+  });
+};
+var defineHarness = (implementation) => {
+  let placeholder = null;
+  const binding = (config) => ({
+    harness: placeholder ?? bundleRef("<pending>"),
+    config,
+    definedHarness: true
+  });
+  const defined = Object.assign(binding, {
+    describe: async (args) => completeHarnessDescription(await implementation.describe(args)),
+    open: (args) => implementation.open({ ...args, sessionId: args.session.sessionId }),
+    resume: (args) => implementation.resume({ ...args, sessionId: args.session.sessionId }),
+    park: (ref, ctx) => implementation.park({ ...ref, ...ctx, ref }, ctx),
+    close: (ref, ctx) => implementation.close({ ...ref, ...ctx, ref }, ctx),
+    health: async (ref, ctx) => {
+      const health = await implementation.health({ ...ref, ...ctx, ref }, ctx);
+      return { ...health, checkedAt: health.checkedAt ?? (/* @__PURE__ */ new Date()).toISOString() };
+    }
+  });
+  placeholder = bundleRef(registerPending(defined));
+  return defined;
+};
+
+export {
+  completeHarnessDescription,
+  defineHarness
+};

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

@@ -0,0 +1,79 @@
+import {
+  stamp
+} from "./chunk-XHKPWT3G.ts";
+import {
+  authoredRecordSchema,
+  isCallable
+} from "./chunk-JIPNTA56.ts";
+import {
+  looseObject
+} from "./chunk-HGW4YHAY.ts";
+
+// src/authoring/hooks.ts
+var HookEvent = /* @__PURE__ */ ((HookEvent2) => {
+  HookEvent2["SessionOpened"] = "session.opened";
+  HookEvent2["TurnStarted"] = "turn.started";
+  HookEvent2["TurnEnded"] = "turn.ended";
+  HookEvent2["UserMessageChunk"] = "user_message_chunk";
+  HookEvent2["AgentMessageChunk"] = "agent_message_chunk";
+  HookEvent2["AgentMessage"] = "agent_message";
+  HookEvent2["AgentThoughtChunk"] = "agent_thought_chunk";
+  HookEvent2["ToolCall"] = "tool_call";
+  HookEvent2["ToolCallUpdate"] = "tool_call_update";
+  HookEvent2["ToolCallContentChunk"] = "tool_call_content_chunk";
+  HookEvent2["Plan"] = "plan";
+  HookEvent2["PendingCreated"] = "pending.created";
+  HookEvent2["PendingResolved"] = "pending.resolved";
+  HookEvent2["StateUpdate"] = "state_update";
+  HookEvent2["SessionFailed"] = "session.failed";
+  HookEvent2["SessionClosed"] = "session.closed";
+  HookEvent2["CompactionUpdate"] = "compaction_update";
+  HookEvent2["UsageUpdate"] = "usage_update";
+  HookEvent2["AvailableCommandsUpdate"] = "available_commands_update";
+  HookEvent2["CurrentModeUpdate"] = "current_mode_update";
+  HookEvent2["ConfigOptionUpdate"] = "config_option_update";
+  HookEvent2["SessionInfoUpdate"] = "session_info_update";
+  HookEvent2["Notice"] = "notice";
+  return HookEvent2;
+})(HookEvent || {});
+var HOOK_WILDCARD = "*";
+var CANONICAL_EVENTS = new Set(Object.values(HookEvent));
+var HookEventKeyKind = /* @__PURE__ */ ((HookEventKeyKind2) => {
+  HookEventKeyKind2["Canonical"] = "canonical";
+  HookEventKeyKind2["Wildcard"] = "wildcard";
+  HookEventKeyKind2["Unknown"] = "unknown";
+  return HookEventKeyKind2;
+})(HookEventKeyKind || {});
+var normalizeHookKey = (key) => {
+  if (key === HOOK_WILDCARD)
+    return { key, kind: "wildcard" /* Wildcard */, events: [HOOK_WILDCARD] };
+  if (CANONICAL_EVENTS.has(key) || key.startsWith("_final/")) {
+    return { key, kind: "canonical" /* Canonical */, events: [key] };
+  }
+  return { key, kind: "unknown" /* Unknown */, events: [] };
+};
+var defineHook = (definition) => stamp({ ...definition }, "hook" /* Hook */);
+var keyMatches = (key, event) => key === event.type && (CANONICAL_EVENTS.has(key) || key.startsWith("_final/"));
+var hookEventsSchema = looseObject({ events: authoredRecordSchema });
+var hookHandlersFor = (hook, event) => {
+  const parsed = hookEventsSchema.safeParse(hook);
+  if (!parsed.success) return [];
+  const typed = [];
+  let wildcard = null;
+  for (const [key, handler] of Object.entries(parsed.data.events)) {
+    if (!isCallable(handler)) continue;
+    const invoke = (dispatched, ctx) => handler(dispatched, ctx);
+    if (key === HOOK_WILDCARD) wildcard = invoke;
+    else if (keyMatches(key, event)) typed.push(invoke);
+  }
+  return wildcard == null ? typed : [...typed, wildcard];
+};
+
+export {
+  HookEvent,
+  HOOK_WILDCARD,
+  HookEventKeyKind,
+  normalizeHookKey,
+  defineHook,
+  hookHandlersFor
+};

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

@@ -0,0 +1,13 @@
+// src/authoring/context.ts
+var TranscriptRole = /* @__PURE__ */ ((TranscriptRole2) => {
+  TranscriptRole2["User"] = "user";
+  TranscriptRole2["Assistant"] = "assistant";
+  TranscriptRole2["Tool"] = "tool";
+  TranscriptRole2["Thought"] = "thought";
+  TranscriptRole2["Summary"] = "summary";
+  return TranscriptRole2;
+})(TranscriptRole || {});
+
+export {
+  TranscriptRole
+};

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

@@ -0,0 +1,64 @@
+import {
+  array,
+  json,
+  nativeEnum,
+  object,
+  record,
+  string,
+  union,
+  unknown
+} from "./chunk-HGW4YHAY.ts";
+
+// ../agent-provider/src/dynamic.ts
+var DynamicEvent = /* @__PURE__ */ ((DynamicEvent2) => {
+  DynamicEvent2["SessionStarted"] = "session.started";
+  DynamicEvent2["TurnStarted"] = "turn.started";
+  return DynamicEvent2;
+})(DynamicEvent || {});
+var dynamicSlotSchema = object({
+  $dynamic: object({
+    // Bundle export that implements the resolver ('instructions/org-context').
+    resolver: string().min(1),
+    events: array(nativeEnum(DynamicEvent)).min(1),
+    // Final additions so Build can render a slot without resolving it.
+    description: string().optional(),
+    preview: string().optional()
+  })
+});
+var isDynamicSlot = (value) => dynamicSlotSchema.safeParse(value).success;
+var slotOf = (value) => {
+  const parsed = dynamicSlotSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+};
+var listSchema = array(json());
+var objectSchema = record(string(), json());
+var looseListSchema = array(unknown());
+var looseObjectSchema = record(string(), unknown());
+var maybeDynamic = (schema) => union([dynamicSlotSchema, schema]);
+var indexPath = (parent, index) => `${parent}[${index}]`;
+var keyPath = (parent, key) => parent.length === 0 ? key : `${parent}.${key}`;
+var findDynamicSlots = (value, path = "") => {
+  const slot = slotOf(value);
+  if (slot != null) return [{ path, slot }];
+  const list = looseListSchema.safeParse(value);
+  if (list.success) {
+    return list.data.flatMap((item, index) => findDynamicSlots(item, indexPath(path, index)));
+  }
+  const object2 = looseObjectSchema.safeParse(value);
+  if (object2.success) {
+    return Object.entries(object2.data).flatMap(
+      ([key, item]) => findDynamicSlots(item, keyPath(path, key))
+    );
+  }
+  return [];
+};
+var containsDynamicSlot = (value) => findDynamicSlots(value).length > 0;
+
+export {
+  DynamicEvent,
+  dynamicSlotSchema,
+  isDynamicSlot,
+  maybeDynamic,
+  findDynamicSlots,
+  containsDynamicSlot
+};

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

@@ -0,0 +1,19 @@
+import {
+  stamp
+} from "./chunk-XHKPWT3G.ts";
+
+// src/authoring/dynamic.ts
+var defineDynamic = (definition) => {
+  const sentinel = {
+    kind: "final:dynamic",
+    events: definition.events
+  };
+  if (definition.description != null) sentinel.description = definition.description;
+  if (definition.preview != null) sentinel.preview = definition.preview;
+  if (definition.provider != null) sentinel.provider = definition.provider;
+  return stamp(sentinel, "dynamic" /* Dynamic */);
+};
+
+export {
+  defineDynamic
+};

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

@@ -0,0 +1,81 @@
+import {
+  resultMatchesSchema
+} from "./chunk-GNR7XBPN.ts";
+import {
+  stamp
+} from "./chunk-XHKPWT3G.ts";
+import {
+  callableSchema,
+  isObjectLike,
+  optionalValueSchema
+} from "./chunk-JIPNTA56.ts";
+import {
+  array,
+  boolean,
+  looseObject,
+  object,
+  string,
+  union
+} from "./chunk-HGW4YHAY.ts";
+
+// src/authoring/tools.ts
+var toolLabelSchema = union([
+  string(),
+  object({
+    start: callableSchema,
+    delta: callableSchema.optional(),
+    complete: callableSchema.optional()
+  })
+]);
+var defineTool = (definition) => stamp({ ...definition }, "tool" /* Tool */);
+var toolNames = /* @__PURE__ */ new WeakMap();
+var registerToolName = (tool, name) => {
+  if (!isObjectLike(tool)) return;
+  toolNames.set(tool, [...toolNames.get(tool) ?? [], name]);
+};
+var nameMatches = (qualified, name) => qualified === name || qualified.endsWith(`/${name}`) || qualified.endsWith(`__${name}`);
+var toolCallUpdateSchema = looseObject({
+  status: string().nullish(),
+  toolName: string(),
+  rawOutput: optionalValueSchema
+});
+var mcpResultSchema = looseObject({
+  isError: boolean().optional(),
+  structuredContent: optionalValueSchema,
+  content: array(looseObject({ type: string(), text: string().optional() })).optional()
+});
+var toolOutputOf = (rawOutput) => {
+  const result = mcpResultSchema.safeParse(rawOutput);
+  if (!result.success) return { output: rawOutput, failed: false };
+  if (result.data.isError === true) return { output: null, failed: true };
+  if (result.data.structuredContent != null)
+    return { output: result.data.structuredContent, failed: false };
+  const text = result.data.content?.find((block) => block.type === "text")?.text;
+  if (text == null) return { output: rawOutput, failed: false };
+  try {
+    const parsed = JSON.parse(text);
+    return { output: parsed, failed: false };
+  } catch {
+    return { output: text, failed: false };
+  }
+};
+var isToolOutput = (tool, value) => resultMatchesSchema(tool.outputSchema, value);
+var toolResultFrom = (event, tool) => {
+  if (event.type !== "tool_call_update") return void 0;
+  const data = toolCallUpdateSchema.safeParse(event.data);
+  if (!data.success) return void 0;
+  if (data.data.status != null && data.data.status !== "completed") return void 0;
+  const qualified = data.data.toolName;
+  const names = isObjectLike(tool) ? toolNames.get(tool) ?? [] : [];
+  if (!names.some((name) => nameMatches(qualified, name))) return void 0;
+  const { output, failed } = toolOutputOf(data.data.rawOutput);
+  if (failed) return void 0;
+  return isToolOutput(tool, output) ? output : void 0;
+};
+
+export {
+  toolLabelSchema,
+  defineTool,
+  registerToolName,
+  toolResultFrom
+};

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

@@ -0,0 +1,16 @@
+import {
+  stamp
+} from "./chunk-XHKPWT3G.ts";
+
+// src/authoring/instructions.ts
+var defineInstructions = (definition) => stamp(
+  {
+    content: definition.content,
+    role: definition.role === "user" /* User */ ? "user" /* User */ : "system" /* System */
+  },
+  "instructions" /* Instructions */
+);
+
+export {
+  defineInstructions
+};