@finalai/agent-definition 0.1.0

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

@@ -0,0 +1,121 @@
+import {
+  jsonObjectSchema
+} from "./chunk-7QP2CKPI.ts";
+import {
+  stamp
+} from "./chunk-XHKPWT3G.ts";
+import {
+  array,
+  nativeEnum,
+  object,
+  string
+} from "./chunk-HGW4YHAY.ts";
+
+// ../agent-provider/src/channel-context.ts
+var ChannelPrincipalType = /* @__PURE__ */ ((ChannelPrincipalType2) => {
+  ChannelPrincipalType2["User"] = "user";
+  ChannelPrincipalType2["Service"] = "service";
+  return ChannelPrincipalType2;
+})(ChannelPrincipalType || {});
+var channelAuthSchema = object({
+  principalId: string().min(1),
+  principalType: nativeEnum(ChannelPrincipalType),
+  authenticator: string().min(1),
+  attributes: jsonObjectSchema.default({})
+});
+var channelAccessors = (platform) => {
+  const operations = () => {
+    if (platform.channelSessions == null)
+      throw new Error("channel session operations are unavailable");
+    return platform.channelSessions;
+  };
+  const handle = (target) => ({
+    inspect: () => operations().inspect(target),
+    resolveSession: () => operations().resolve(target),
+    send: (input) => operations().send(target, input),
+    respond: (input) => operations().respond(target, input),
+    cancel: (input) => operations().cancel(target, input),
+    close: () => operations().close(target),
+    observe: (input) => operations().observe(target, input),
+    setConfigOption: (input) => operations().setConfigOption(target, input),
+    park: () => operations().park(target),
+    getState: () => operations().getState(target),
+    setState: (state) => operations().setState(target, state)
+  });
+  return {
+    from: (address) => handle({ address }),
+    resolveSession: (address) => operations().resolve({ address }),
+    attachSession: (sessionId) => handle({ sessionId }),
+    to: (channel, target) => ({ send: (input) => operations().handoff(channel, target, input) })
+  };
+};
+
+// ../agent-provider/src/semantic-events.ts
+var channelMessageCompletedSchema = object({
+  message: object({ id: string(), content: array(jsonObjectSchema) }),
+  finishReason: string().nullable()
+});
+var channelTurnEventSchema = object({
+  turnId: string(),
+  stopReason: string().nullable().optional()
+});
+
+// src/authoring/channels.ts
+var defineChannel = (definition) => {
+  const {
+    "message.delta": delta,
+    "message.completed": completed,
+    "turn.started": started,
+    "turn.completed": ended,
+    ...raw
+  } = definition.events ?? {};
+  const events = { ...raw };
+  const wrap = (schema, handler) => handler == null ? void 0 : async (event, ctx) => handler(
+    schema.parse(event.data),
+    { ...channelAccessors(ctx.platform), platform: ctx.platform },
+    {
+      sessionId: ctx.sessionId ?? null,
+      turnId: ctx.turn.id,
+      state: ctx.state
+    }
+  );
+  const semantic = {
+    "message.delta": wrap(object({ messageId: string(), delta: jsonObjectSchema }), delta),
+    "message.completed": wrap(channelMessageCompletedSchema, completed),
+    "turn.started": wrap(object({ turnId: string() }), started),
+    "turn.completed": wrap(
+      object({ turnId: string(), stopReason: string().nullable() }),
+      ended
+    )
+  };
+  for (const [kind, handler] of Object.entries(semantic))
+    if (handler != null) events[kind] = handler;
+  const { installed, configure, ...authored } = definition;
+  return stamp(
+    { ...authored, configure: installed == null ? configure : void 0, events },
+    "channel" /* Channel */
+  );
+};
+var disableChannel = () => defineChannel({ disabled: true });
+var route = (method) => (path, handler) => ({
+  method,
+  path,
+  handler
+});
+var GET = route("GET");
+var POST = route("POST");
+var PUT = route("PUT");
+var DELETE = route("DELETE");
+var WS = (path, handler) => ({ method: "WS", path, handler });
+var defineProviderChannel = (definition) => stamp(definition, "channel" /* Channel */);
+
+export {
+  defineChannel,
+  disableChannel,
+  GET,
+  POST,
+  PUT,
+  DELETE,
+  WS,
+  defineProviderChannel
+};

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

@@ -0,0 +1,55 @@
+import {
+  isObjectLike
+} from "./chunk-JIPNTA56.ts";
+
+// src/authoring/brand.ts
+var AuthoredKind = /* @__PURE__ */ ((AuthoredKind2) => {
+  AuthoredKind2["Agent"] = "agent";
+  AuthoredKind2["Tool"] = "tool";
+  AuthoredKind2["Dynamic"] = "dynamic";
+  AuthoredKind2["Instructions"] = "instructions";
+  AuthoredKind2["Skill"] = "skill";
+  AuthoredKind2["Connection"] = "connection";
+  AuthoredKind2["Schedule"] = "schedule";
+  AuthoredKind2["SandboxSelector"] = "sandbox-selector";
+  AuthoredKind2["BaseTools"] = "base-tools";
+  AuthoredKind2["HarnessHost"] = "harness-host";
+  AuthoredKind2["Hook"] = "hook";
+  AuthoredKind2["Channel"] = "channel";
+  AuthoredKind2["Approval"] = "approval";
+  return AuthoredKind2;
+})(AuthoredKind || {});
+var kinds = /* @__PURE__ */ new WeakMap();
+var stamp = (value, kind) => {
+  kinds.set(value, kind);
+  return value;
+};
+var authoredKindOf = (value) => isObjectLike(value) ? kinds.get(value) ?? null : null;
+var isAuthored = (value, kind) => authoredKindOf(value) === kind;
+var PENDING_PREFIX = "<pending:";
+var pendingValues = [];
+var registerPending = (value) => {
+  pendingValues.push(value);
+  return `${PENDING_PREFIX}${pendingValues.length - 1}>`;
+};
+var pendingEntries = () => pendingValues.map((value, index) => ({
+  placeholder: `${PENDING_PREFIX}${index}>`,
+  index,
+  value
+}));
+var pendingIndexOf = (placeholder) => {
+  const match = /^<pending:(\d+)>$/.exec(placeholder);
+  return match?.[1] == null ? null : Number(match[1]);
+};
+var pendingExportName = (index) => `pending:${index}`;
+
+export {
+  AuthoredKind,
+  stamp,
+  authoredKindOf,
+  isAuthored,
+  registerPending,
+  pendingEntries,
+  pendingIndexOf,
+  pendingExportName
+};

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

@@ -0,0 +1,476 @@
+import {
+  toolLabelSchema
+} from "./chunk-TATN3PYK.ts";
+import {
+  jsonSchemaDeclarationError
+} from "./chunk-GNR7XBPN.ts";
+import {
+  lowerApproval
+} from "./chunk-7VSSVZM4.ts";
+import {
+  authoredKindOf,
+  pendingExportName,
+  pendingIndexOf
+} from "./chunk-XHKPWT3G.ts";
+import {
+  authoredRecordSchema,
+  authoredValueSchema,
+  callableSchema,
+  entriesOf,
+  fieldOf,
+  isBoolean,
+  isCallable,
+  isNumber,
+  isObjectLike,
+  isPlainObject,
+  isString,
+  messageOf,
+  optionalValueSchema
+} from "./chunk-JIPNTA56.ts";
+import {
+  ZodType,
+  array,
+  boolean,
+  literal,
+  looseObject,
+  object,
+  record,
+  string,
+  toJSONSchema,
+  union,
+  url
+} from "./chunk-HGW4YHAY.ts";
+
+// src/runtime/lower.ts
+var IssueSeverity = /* @__PURE__ */ ((IssueSeverity2) => {
+  IssueSeverity2["Error"] = "error";
+  IssueSeverity2["Warning"] = "warning";
+  IssueSeverity2["Note"] = "note";
+  return IssueSeverity2;
+})(IssueSeverity || {});
+var error = (message) => ({ severity: "error" /* Error */, message });
+var warning = (message) => ({
+  severity: "warning" /* Warning */,
+  message
+});
+var note = (message) => ({ severity: "note" /* Note */, message });
+var childPath = (parent, key) => {
+  if (isNumber(key)) return `${parent}[${key}]`;
+  return parent.length === 0 ? key : `${parent}.${key}`;
+};
+var PENDING_PLACEHOLDER = /^<pending:\d+>$/;
+var label = (path) => path.length === 0 ? "value" : path;
+var toJson = (value, options) => {
+  const visited = options.visit?.(value, options.path);
+  if (visited !== void 0) return visited;
+  if (value == null) return null;
+  if (isString(value)) {
+    const index = PENDING_PLACEHOLDER.test(value) ? pendingIndexOf(value) : null;
+    return index == null ? value : pendingExportName(index);
+  }
+  if (isNumber(value)) {
+    if (Number.isFinite(value)) return value;
+    options.issues.push(error(`${label(options.path)} is not a finite number`));
+    return null;
+  }
+  if (isBoolean(value)) return value;
+  if (Array.isArray(value)) {
+    return value.map(
+      (item, index) => toJson(item, { ...options, path: childPath(options.path, index) })
+    );
+  }
+  if (isCallable(value)) {
+    options.issues.push(
+      error(`${label(options.path)} is a function; only static values can appear here`)
+    );
+    return null;
+  }
+  if (isPlainObject(value) || authoredKindOf(value) != null) {
+    const out = {};
+    for (const [key, item] of entriesOf(value)) {
+      if (item === void 0) continue;
+      out[key] = toJson(item, { ...options, path: childPath(options.path, key) });
+    }
+    return out;
+  }
+  options.issues.push(
+    error(`${label(options.path)} is not JSON (${Object.prototype.toString.call(value)})`)
+  );
+  return null;
+};
+var jsonSchemaObjectSchema = record(string(), authoredValueSchema);
+var standardJsonSchemaSchema = looseObject({
+  "~standard": looseObject({
+    jsonSchema: looseObject({ input: callableSchema, output: callableSchema.optional() }).optional()
+  })
+});
+var isZodSchema = (value) => value instanceof ZodType;
+var toJsonSchema = (args) => {
+  const { schema, path, issues } = args;
+  const io = args.io ?? "input" /* Input */;
+  const standard = standardJsonSchemaSchema.safeParse(schema);
+  const jsonSchema = fieldOf(fieldOf(schema, "~standard"), "jsonSchema");
+  let converted = null;
+  if (standard.success && standard.data["~standard"].jsonSchema != null) {
+    try {
+      const convert = standard.data["~standard"].jsonSchema[io];
+      if (convert == null) throw new Error(`Standard JSON Schema has no ${io} converter`);
+      converted = convert.call(jsonSchema, {
+        target: "draft-2020-12"
+      });
+    } catch (cause) {
+      issues.push(error(`${path} could not be converted to JSON Schema: ${messageOf(cause)}`));
+      return null;
+    }
+  } else if (isZodSchema(schema)) {
+    converted = toJSONSchema(schema, { io });
+  } else if (standard.success) {
+    issues.push(
+      error(
+        `${path} is a Standard Schema without JSON Schema support; use zod 4 or a JSON Schema object`
+      )
+    );
+    return null;
+  } else if (isPlainObject(schema)) {
+    converted = schema;
+  } else {
+    issues.push(error(`${path} must be a zod schema or a JSON Schema object`));
+    return null;
+  }
+  const json = toJson(converted, { path, issues });
+  if (json == null || Array.isArray(json) || !jsonSchemaObjectSchema.safeParse(json).success || !isPlainObject(json)) {
+    issues.push(error(`${path} did not produce a JSON Schema object`));
+    return null;
+  }
+  const out = {};
+  for (const [key, item] of Object.entries(json)) {
+    if (key !== "$schema" || !standard.success && !isZodSchema(schema)) out[key] = item;
+  }
+  const declarationError = jsonSchemaDeclarationError(out);
+  if (declarationError != null) {
+    issues.push(error(`${path} is an invalid JSON Schema: ${declarationError}`));
+    return null;
+  }
+  return out;
+};
+var authoredToolSchema = looseObject({
+  description: optionalValueSchema,
+  execute: optionalValueSchema,
+  inputSchema: optionalValueSchema,
+  outputSchema: optionalValueSchema,
+  endsTurn: optionalValueSchema,
+  approval: optionalValueSchema,
+  label: optionalValueSchema,
+  annotations: looseObject({
+    title: string().optional(),
+    readOnlyHint: boolean().optional(),
+    destructiveHint: boolean().optional(),
+    idempotentHint: boolean().optional(),
+    openWorldHint: boolean().optional()
+  }).optional().catch(void 0)
+});
+var lowerTool = (args) => {
+  const issues = [];
+  const path = `tool ${args.name}`;
+  const parsed = authoredToolSchema.safeParse(args.value);
+  if (!parsed.success) {
+    issues.push(error(`${path} must be defineTool({ description, inputSchema, execute })`));
+    return {
+      descriptor: {
+        name: args.name,
+        description: "",
+        inputSchema: { type: "object" },
+        export: args.exportName
+      },
+      approval: "ask" /* Ask */,
+      issues
+    };
+  }
+  const tool = parsed.data;
+  const description = isString(tool.description) ? tool.description : "";
+  if (description.length === 0) issues.push(error(`${path} needs a description`));
+  if (!isCallable(tool.execute)) issues.push(error(`${path} needs an execute function`));
+  const inputSchema = toJsonSchema({
+    schema: tool.inputSchema,
+    path: `${path} inputSchema`,
+    issues
+  }) ?? {
+    type: "object"
+  };
+  if (tool.endsTurn != null && tool.endsTurn !== false) {
+    issues.push(
+      error(`${path} sets endsTurn; it is not supported because the harness owns the loop`)
+    );
+  }
+  const approval = lowerApproval(tool.approval);
+  if (approval.error != null) issues.push(error(`${path}: ${approval.error}`));
+  if (approval.note != null) issues.push(note(`${path}: ${approval.note}`));
+  const descriptor = {
+    name: args.name,
+    description,
+    inputSchema,
+    export: args.exportName
+  };
+  if (approval.inputDependent)
+    descriptor.inputApproval = { kind: "tool" /* Tool */, export: args.exportName };
+  if (tool.outputSchema != null) {
+    const outputSchema = toJsonSchema({
+      schema: tool.outputSchema,
+      path: `${path} outputSchema`,
+      issues,
+      io: "output" /* Output */
+    });
+    if (outputSchema != null) descriptor.outputSchema = outputSchema;
+  }
+  const annotations = { ...tool.annotations };
+  if (tool.label != null && !toolLabelSchema.safeParse(tool.label).success)
+    issues.push(error(`${path} label must be text or { start, delta?, complete? } callbacks`));
+  if (isString(tool.label)) annotations.title = tool.label;
+  if (Object.keys(annotations).length > 0) descriptor.annotations = annotations;
+  return { descriptor, approval: approval.policy, issues };
+};
+var authoredConnectionSchema = looseObject({
+  url: optionalValueSchema,
+  auth: optionalValueSchema,
+  headers: optionalValueSchema,
+  approval: optionalValueSchema,
+  toolCall: optionalValueSchema,
+  tools: looseObject({
+    allow: array(string()).optional(),
+    deny: array(string()).optional(),
+    approval: authoredRecordSchema.optional()
+  }).optional()
+});
+var connectionAuthSchema = union([
+  object({ kind: literal("final-session") }).transform(() => ({ kind: "final-session" })),
+  looseObject({ secretKey: string().min(1), headerName: string().nullish() }).transform((auth) => ({ secretKey: auth.secretKey, headerName: auth.headerName ?? null }))
+]);
+var stringRecord = (value, path, issues) => {
+  if (value == null) return {};
+  const parsed = record(string(), string()).safeParse(value);
+  if (parsed.success) return parsed.data;
+  issues.push(error(`${path} must be a record of strings (header callbacks are not supported)`));
+  return {};
+};
+var lowerAuth = (value, path, issues) => {
+  if (value == null) return null;
+  const parsed = connectionAuthSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  issues.push(
+    error(
+      `${path} must be { secretKey, headerName } or { kind: 'final-session' }; auth providers and callbacks are not supported`
+    )
+  );
+  return null;
+};
+var lowerConnection = (args) => {
+  const issues = [];
+  const path = `connection ${args.key}`;
+  const parsed = authoredConnectionSchema.safeParse(args.value);
+  const connection = parsed.success ? parsed.data : null;
+  if (connection == null)
+    issues.push(error(`${path} must be defineMcpClientConnection({ url, ... })`));
+  const url2 = isString(connection?.url) ? connection.url : null;
+  if (url2 == null || !url().safeParse(url2).success)
+    issues.push(error(`${path} needs a valid url`));
+  const tools = connection?.tools;
+  const defaultApproval = lowerApproval(connection?.approval);
+  if (defaultApproval.error != null) issues.push(error(`${path}: ${defaultApproval.error}`));
+  if (defaultApproval.note != null) issues.push(note(`${path}: ${defaultApproval.note}`));
+  const overrideEntries = [];
+  const inputApprovalEntries = [];
+  const staticOverrideKeys = [];
+  if (defaultApproval.inputDependent)
+    inputApprovalEntries.push([
+      "*",
+      { kind: "connection" /* Connection */, export: args.exportName }
+    ]);
+  for (const [tool, approval] of Object.entries(tools?.approval ?? {})) {
+    const lowered = lowerApproval(approval);
+    if (lowered.error != null)
+      issues.push(error(`${path} tools.approval.${tool}: ${lowered.error}`));
+    if (lowered.note != null) issues.push(note(`${path} tools.approval.${tool}: ${lowered.note}`));
+    overrideEntries.push([tool, lowered.policy]);
+    if (lowered.inputDependent)
+      inputApprovalEntries.push([
+        tool,
+        { kind: "connection" /* Connection */, export: args.exportName, policyKey: tool }
+      ]);
+    else staticOverrideKeys.push(tool);
+  }
+  const overrides = Object.fromEntries(overrideEntries);
+  const inputApprovals = Object.fromEntries(inputApprovalEntries);
+  for (const key of staticOverrideKeys) delete inputApprovals[key];
+  const defaultPolicy = overrides["*"] ?? defaultApproval.policy;
+  const allow = tools?.allow ?? null;
+  let approvals = null;
+  if (allow != null) {
+    approvals = Object.fromEntries(allow.map((tool) => [tool, overrides[tool] ?? defaultPolicy]));
+    const inherited = Object.hasOwn(inputApprovals, "*") ? inputApprovals["*"] : void 0;
+    if (inherited != null) {
+      for (const tool of allow) {
+        if (!Object.hasOwn(overrides, tool))
+          Object.defineProperty(inputApprovals, tool, {
+            value: inherited,
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+      }
+    }
+    for (const tool of Object.keys(overrides)) {
+      if (!allow.includes(tool)) {
+        issues.push(
+          warning(`${path} sets an approval for ${tool}, which tools.allow does not expose`)
+        );
+      }
+    }
+  } else if (defaultApproval.policy === "ask" /* Ask */ || Object.keys(overrides).length > 0) {
+    approvals = { "*": defaultApproval.policy, ...overrides };
+  }
+  const deny = tools?.deny ?? [];
+  for (const tool of deny) {
+    if (Object.hasOwn(overrides, tool))
+      issues.push(warning(`${path} sets an approval for ${tool}, which tools.deny hides`));
+  }
+  if (connection?.toolCall != null)
+    issues.push(error(`${path} uses toolCall.providedArguments, which is not supported`));
+  const binding = {
+    key: args.key,
+    kind: "http" /* Http */,
+    url: url2 ?? "https://invalid.invalid",
+    auth: lowerAuth(connection?.auth, `${path} auth`, issues),
+    headers: stringRecord(connection?.headers, `${path} headers`, issues),
+    approvals
+  };
+  if (deny.length > 0) binding.deny = [...new Set(deny)];
+  if (Object.keys(inputApprovals).length > 0) binding.inputApprovals = inputApprovals;
+  return { binding, issues };
+};
+var skillMarkdown = (args) => args.markdown.startsWith("---\n") ? args.markdown : `---
+name: ${JSON.stringify(args.key)}
+description: ${JSON.stringify(args.description)}
+---
+
+${args.markdown}`;
+var authoredSkillSchema = looseObject({
+  description: optionalValueSchema,
+  markdown: optionalValueSchema,
+  files: authoredRecordSchema.optional().catch(void 0)
+});
+var lowerSkill = (args) => {
+  const issues = [];
+  const parsed = authoredSkillSchema.safeParse(args.value);
+  const description = parsed.success && isString(parsed.data.description) ? parsed.data.description : null;
+  const markdown = parsed.success && isString(parsed.data.markdown) ? parsed.data.markdown : null;
+  if (description == null || description.length === 0)
+    issues.push(error(`skill ${args.key} needs a description`));
+  if (markdown == null) issues.push(error(`skill ${args.key} needs markdown`));
+  const files = [
+    {
+      path: "SKILL.md",
+      content: skillMarkdown({
+        key: args.key,
+        description: description ?? "",
+        markdown: markdown ?? ""
+      })
+    }
+  ];
+  for (const [path, content] of Object.entries(
+    (parsed.success ? parsed.data.files : void 0) ?? {}
+  )) {
+    if (path.startsWith("/") || path.split(/[\\/]/).includes("..")) {
+      issues.push(error(`skill ${args.key} file ${path} must stay inside the skill directory`));
+    } else if (!isString(content)) {
+      issues.push(warning(`skill ${args.key} file ${path} is binary and was left out`));
+    } else if (path !== "SKILL.md") files.push({ path, content });
+  }
+  const skill = { key: args.key, files };
+  if (description != null) skill.description = description;
+  return { skill, issues };
+};
+var authoredInstructionsSchema = looseObject({
+  content: string(),
+  role: string().optional()
+});
+var lowerInstructions = (value, source) => {
+  const parsed = authoredInstructionsSchema.safeParse(value);
+  if (!parsed.success) return null;
+  const fragment = {
+    role: parsed.data.role === "user" /* User */ ? "user" /* User */ : "system" /* System */,
+    content: parsed.data.content
+  };
+  if (source != null) fragment.source = source;
+  return fragment;
+};
+var environmentSchema = looseObject({
+  providerName: string(),
+  providerRef: optionalValueSchema,
+  options: optionalValueSchema,
+  open: callableSchema
+});
+var openRequestSchema = looseObject({
+  providerName: string(),
+  providerRef: optionalValueSchema,
+  environmentOptions: optionalValueSchema,
+  openOptions: optionalValueSchema
+});
+var sandboxProviderSchema = looseObject({
+  name: string(),
+  environment: callableSchema,
+  definition: looseObject({})
+});
+var isEnvironmentLike = (value) => environmentSchema.safeParse(value).success;
+var isOpenRequestLike = (value) => openRequestSchema.safeParse(value).success && isObjectLike(value) && "environmentOptions" in value;
+var sandboxProviderNameOf = (value) => {
+  const parsed = sandboxProviderSchema.safeParse(value);
+  return parsed.success ? parsed.data.name : null;
+};
+var lowerEnvironment = (value, path, issues) => {
+  const warnings = array(string()).safeParse(fieldOf(value, "authoringWarnings"));
+  if (warnings.success)
+    for (const message of warnings.data) issues.push(warning(`${path}: ${message}`));
+  const request = isOpenRequestLike(value) ? openRequestSchema.safeParse(value) : null;
+  if (request?.success === true) {
+    return {
+      providerName: request.data.providerName,
+      providerRef: request.data.providerRef == null ? null : toJson(request.data.providerRef, { path, issues }),
+      options: toJson(request.data.environmentOptions ?? {}, { path: `${path} options`, issues }),
+      openOptions: toJson(request.data.openOptions ?? null, {
+        path: `${path} open options`,
+        issues
+      })
+    };
+  }
+  const environment = environmentSchema.safeParse(value);
+  if (!environment.success) return null;
+  return {
+    providerName: environment.data.providerName,
+    providerRef: environment.data.providerRef == null ? null : toJson(environment.data.providerRef, { path, issues }),
+    options: toJson(environment.data.options ?? {}, { path: `${path} options`, issues }),
+    openOptions: null
+  };
+};
+var isDynamicSentinel = (value) => authoredKindOf(value) === "dynamic" /* Dynamic */;
+var dynamicEventsOf = (value) => entriesOf(fieldOf(value, "events")).filter(([, handler]) => isCallable(handler)).map(([event]) => event);
+
+export {
+  IssueSeverity,
+  error,
+  warning,
+  note,
+  childPath,
+  toJson,
+  toJsonSchema,
+  lowerTool,
+  lowerConnection,
+  skillMarkdown,
+  lowerSkill,
+  lowerInstructions,
+  isEnvironmentLike,
+  isOpenRequestLike,
+  sandboxProviderNameOf,
+  lowerEnvironment,
+  isDynamicSentinel,
+  dynamicEventsOf
+};

package/dist/compiler-assets/src/authoring/agent.ts

@@ -0,0 +1,10 @@
+import {
+  defineAgent
+} from "../../chunk-2CZRHOLL.ts";
+import "../../chunk-XHKPWT3G.ts";
+import "../../chunk-JIPNTA56.ts";
+import "../../chunk-HGW4YHAY.ts";
+import "../../chunk-32O3ODZE.ts";
+export {
+  defineAgent
+};

package/dist/compiler-assets/src/authoring/approval.ts

@@ -0,0 +1,19 @@
+import {
+  always,
+  lowerApproval,
+  never,
+  whenInput
+} from "../../chunk-7VSSVZM4.ts";
+import "../../chunk-OWC6SFFF.ts";
+import "../../chunk-7QP2CKPI.ts";
+import "../../chunk-SKTNMUO7.ts";
+import "../../chunk-XHKPWT3G.ts";
+import "../../chunk-JIPNTA56.ts";
+import "../../chunk-HGW4YHAY.ts";
+import "../../chunk-32O3ODZE.ts";
+export {
+  always,
+  lowerApproval,
+  never,
+  whenInput
+};