@finalai/agent-definition 0.1.0

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

@@ -0,0 +1,481 @@
+import {
+  isDynamicSentinel,
+  isEnvironmentLike,
+  isOpenRequestLike,
+  lowerConnection,
+  lowerEnvironment,
+  lowerInstructions,
+  lowerSkill,
+  lowerTool,
+  toJson
+} from "./chunk-ZDLVA6XF.ts";
+import {
+  AUTHORED_SERVER_KEY
+} from "./chunk-NMYHO2QN.ts";
+import {
+  hookHandlersFor
+} from "./chunk-QMWTDPNT.ts";
+import {
+  unopenedRequestOf
+} from "./chunk-CWWRTRWW.ts";
+import {
+  registerToolName,
+  toolLabelSchema
+} from "./chunk-TATN3PYK.ts";
+import {
+  validateSchemaValue
+} from "./chunk-GNR7XBPN.ts";
+import {
+  lowerApproval
+} from "./chunk-7VSSVZM4.ts";
+import {
+  mcpServerBindingSchema,
+  providerRefSchema
+} from "./chunk-OWC6SFFF.ts";
+import {
+  ConversationKind,
+  ParticipantKind
+} from "./chunk-5BK6FVRE.ts";
+import {
+  jsonObjectSchema,
+  jsonValueSchema
+} from "./chunk-7QP2CKPI.ts";
+import {
+  TranscriptRole
+} from "./chunk-RWUIMTBI.ts";
+import {
+  DynamicEvent
+} from "./chunk-SKTNMUO7.ts";
+import {
+  authoredKindOf,
+  stamp
+} from "./chunk-XHKPWT3G.ts";
+import {
+  authoredRecordSchema,
+  callableSchema,
+  entriesOf,
+  fieldOf,
+  isAsyncIterable,
+  isCallable,
+  isObjectLike,
+  isPlainObject,
+  messageOf,
+  optionalValueSchema
+} from "./chunk-JIPNTA56.ts";
+import {
+  array,
+  boolean,
+  looseObject,
+  nativeEnum,
+  number,
+  object,
+  string
+} from "./chunk-HGW4YHAY.ts";
+
+// src/runtime/isolate.ts
+var jsonOf = (value, path) => {
+  const issues = [];
+  const json = toJson(value, { path, issues });
+  const failure = issues.find((issue) => issue.severity === "error");
+  if (failure != null) throw new Error(failure.message);
+  return json;
+};
+var lastSegment = (exportName) => {
+  const base = exportName.split("#")[0] ?? exportName;
+  return base.split("/").at(-1) ?? base;
+};
+var lowerResolvedValue = (value, key) => {
+  if (value == null) return null;
+  const kind = authoredKindOf(value);
+  if (kind === "instructions" /* Instructions */)
+    return jsonOf(lowerInstructions(value, null), "instructions");
+  if (kind === "skill" /* Skill */) {
+    const lowered = lowerSkill({ key, value });
+    const failure = lowered.issues.find((issue) => issue.severity === "error");
+    if (failure != null) throw new Error(failure.message);
+    return jsonOf(lowered.skill, "skill");
+  }
+  if (isEnvironmentLike(value) || isOpenRequestLike(value)) {
+    const issues = [];
+    const environment = lowerEnvironment(value, "environment", issues);
+    return jsonOf(environment, "environment");
+  }
+  if (isPlainObject(value)) {
+    const entries = entriesOf(value);
+    if (entries.length > 0 && entries.every(([, item]) => authoredKindOf(item) === "skill" /* Skill */)) {
+      return entries.map(
+        ([entryKey, item]) => jsonOf(lowerSkill({ key: entryKey, value: item }).skill, "skill")
+      );
+    }
+  }
+  return jsonOf(value, "resolved value");
+};
+var throwOnErrors = (issues) => {
+  const failure = issues.find((issue) => issue.severity === "error");
+  if (failure != null) throw new Error(failure.message);
+};
+var combineMcpServers = (entries) => {
+  const handler = (event) => async (payload, ctx) => {
+    const previous = array(mcpServerBindingSchema).safeParse(ctx.previousValue).data ?? [];
+    const tools = [];
+    const approvals = {};
+    const connections = [];
+    const addTool = (name, exportName, value, resolver) => {
+      const lowered = lowerTool({ name, exportName, value });
+      throwOnErrors(lowered.issues);
+      registerToolName(value, name);
+      if (resolver != null) {
+        const snapshot = jsonObjectSchema.parse(
+          jsonOf(
+            {
+              resolver,
+              name,
+              event,
+              payload,
+              session: ctx.session,
+              messages: ctx.messages,
+              channel: ctx.channel
+            },
+            "dynamic tool boundary"
+          )
+        );
+        lowered.descriptor.dynamic = snapshot;
+        if (lowered.descriptor.inputApproval != null)
+          lowered.descriptor.inputApproval = {
+            ...lowered.descriptor.inputApproval,
+            dynamic: snapshot
+          };
+      }
+      tools.push(lowered.descriptor);
+      approvals[name] = lowered.approval;
+    };
+    const addConnection = (key, exportName, value, resolver) => {
+      const lowered = lowerConnection({ key, exportName, value });
+      throwOnErrors(lowered.issues);
+      if (resolver != null && lowered.binding.inputApprovals != null) {
+        const snapshot = jsonObjectSchema.parse(
+          jsonOf(
+            {
+              resolver,
+              name: key,
+              event,
+              payload,
+              session: ctx.session,
+              messages: ctx.messages,
+              channel: ctx.channel
+            },
+            "dynamic connection boundary"
+          )
+        );
+        lowered.binding.inputApprovals = Object.fromEntries(
+          Object.entries(lowered.binding.inputApprovals).map(([name, reference]) => [
+            name,
+            { ...reference, dynamic: snapshot }
+          ])
+        );
+      }
+      connections.push(
+        resolver == null ? lowered.binding : { ...lowered.binding, dynamicResolver: resolver }
+      );
+    };
+    for (const entry of entries) {
+      const add = entry.kind === "tool" ? addTool : (name, exportName, value) => addConnection(name, exportName, value);
+      if (!isDynamicSentinel(entry.value)) {
+        add(entry.key, entry.exportName, entry.value);
+        continue;
+      }
+      const resolve = fieldOf(fieldOf(entry.value, "events"), event);
+      if (!isCallable(resolve)) {
+        for (const server of previous) {
+          if (entry.kind === "connection" && server.kind === "http" /* Http */ && server.dynamicResolver === entry.exportName) {
+            connections.push(server);
+          } else if (entry.kind === "tool" && server.kind === "worker" /* Worker */) {
+            for (const tool of server.tools) {
+              if (tool.dynamic?.["resolver"] !== entry.exportName) continue;
+              tools.push(tool);
+              approvals[tool.name] = Object.hasOwn(server.approvals ?? {}, tool.name) ? server.approvals?.[tool.name] ?? "allow" /* Allow */ : "allow" /* Allow */;
+            }
+          }
+        }
+        continue;
+      }
+      const result = await resolve(payload, ctx);
+      if (result == null) continue;
+      const kind = authoredKindOf(result);
+      if (kind === "tool" /* Tool */ || kind === "connection" /* Connection */) {
+        if (entry.kind === "tool") addTool(entry.key, entry.exportName, result, entry.exportName);
+        else addConnection(entry.key, entry.exportName, result, entry.exportName);
+      } else if (isPlainObject(result)) {
+        for (const [name, item] of entriesOf(result)) {
+          if (entry.kind === "tool")
+            addTool(name, `${entry.exportName}#${name}`, item, entry.exportName);
+          else addConnection(name, `${entry.exportName}#${name}`, item, entry.exportName);
+        }
+      }
+    }
+    const servers = [];
+    if (tools.length > 0) {
+      servers.push({
+        key: AUTHORED_SERVER_KEY,
+        kind: "worker" /* Worker */,
+        tools,
+        approvals
+      });
+    }
+    return jsonOf([...servers, ...connections], "mcpServers");
+  };
+  return stamp(
+    {
+      kind: "final:dynamic",
+      events: {
+        ["session.started" /* SessionStarted */]: handler("session.started" /* SessionStarted */),
+        ["turn.started" /* TurnStarted */]: handler("turn.started" /* TurnStarted */)
+      }
+    },
+    "dynamic" /* Dynamic */
+  );
+};
+var matchRoute = (pattern, path) => {
+  const patternParts = pattern.split("/").filter((part) => part.length > 0);
+  const pathParts = path.split("/").filter((part) => part.length > 0);
+  if (patternParts.length !== pathParts.length) return false;
+  return patternParts.every((part, index) => part.startsWith(":") || part === pathParts[index]);
+};
+var toolModuleSchema = looseObject({
+  execute: callableSchema,
+  inputSchema: optionalValueSchema,
+  outputSchema: optionalValueSchema,
+  toModelOutput: callableSchema.optional(),
+  label: toolLabelSchema.nullish()
+});
+var sentinelSchema = looseObject({ events: authoredRecordSchema });
+var channelModuleSchema = looseObject({
+  configure: callableSchema.optional(),
+  routes: array(looseObject({ method: string(), path: string(), handler: callableSchema }))
+});
+var dynamicToolBoundarySchema = object({
+  resolver: string(),
+  name: string(),
+  event: nativeEnum(DynamicEvent),
+  payload: object({
+    type: nativeEnum(DynamicEvent),
+    prompt: array(jsonValueSchema).nullable()
+  }),
+  session: object({
+    id: string(),
+    organizationId: string(),
+    definitionId: string(),
+    revisionId: string(),
+    conversation: object({
+      id: string(),
+      kind: nativeEnum(ConversationKind),
+      title: string().nullable(),
+      metadata: jsonObjectSchema,
+      participants: array(
+        object({
+          id: string(),
+          kind: nativeEnum(ParticipantKind),
+          displayName: string(),
+          userId: string().nullable()
+        })
+      )
+    }).nullable(),
+    author: object({
+      participantId: string().nullable(),
+      userId: string().nullable(),
+      displayName: string()
+    }).nullable(),
+    turn: object({ id: string() }).nullable(),
+    harness: providerRefSchema
+  }),
+  messages: array(
+    object({
+      role: nativeEnum(TranscriptRole),
+      content: array(jsonValueSchema),
+      toolCallId: string().nullable(),
+      seq: number()
+    })
+  ),
+  channel: object({ kind: string().nullable() })
+});
+var createIsolateRuntime = (modules) => {
+  const lookup = (name) => {
+    if (!(name in modules)) throw new Error(`bundle has no export ${name}`);
+    return modules[name];
+  };
+  const resolveAuthored = async (args) => {
+    if (args.dynamic == null) return lookup(args.exportName);
+    const boundary = dynamicToolBoundarySchema.parse(args.dynamic);
+    if (args.exportName !== boundary.resolver && args.exportName !== `${boundary.resolver}#${boundary.name}`)
+      throw new Error("dynamic export does not match its boundary");
+    const sentinel = lookup(boundary.resolver);
+    if (!isDynamicSentinel(sentinel)) throw new Error("dynamic resolver is not a defineDynamic");
+    const resolve = fieldOf(fieldOf(sentinel, "events"), boundary.event);
+    if (!isCallable(resolve)) throw new Error("dynamic resolver has no boundary handler");
+    const result = await resolve(boundary.payload, {
+      session: boundary.session,
+      messages: boundary.messages,
+      channel: boundary.channel,
+      secrets: args.secrets
+    });
+    const expected = args.kind === "tool" /* Tool */ ? "tool" /* Tool */ : "connection" /* Connection */;
+    return authoredKindOf(result) === expected ? result : fieldOf(result, boundary.name);
+  };
+  return {
+    evaluateApproval: async ({ reference, input, secrets }) => {
+      const value = await resolveAuthored({
+        exportName: reference.export,
+        dynamic: reference.dynamic,
+        kind: reference.kind,
+        secrets
+      });
+      let policy;
+      let validated = input;
+      if (reference.kind === "tool" /* Tool */) {
+        const tool = toolModuleSchema.parse(value);
+        validated = await validateSchemaValue({
+          schema: tool.inputSchema,
+          value: input,
+          what: "approval input"
+        });
+        policy = fieldOf(value, "approval");
+      } else {
+        if (authoredKindOf(value) !== "connection" /* Connection */)
+          throw new Error("approval export is not a connection");
+        policy = reference.policyKey == null ? fieldOf(value, "approval") : fieldOf(fieldOf(fieldOf(value, "tools"), "approval"), reference.policyKey);
+      }
+      const lowered = lowerApproval(policy);
+      const predicate = fieldOf(policy, "predicate");
+      if (lowered.error != null || !lowered.inputDependent || !isCallable(predicate))
+        throw new Error("approval reference has no valid input predicate");
+      return boolean().parse(await predicate(validated)) ? "ask" /* Ask */ : "allow" /* Allow */;
+    },
+    runTool: async (args) => {
+      const value = await resolveAuthored({
+        exportName: args.export,
+        dynamic: args.dynamic,
+        kind: "tool" /* Tool */,
+        secrets: args.ctx.secrets
+      });
+      if (args.dynamic != null)
+        registerToolName(value, dynamicToolBoundarySchema.parse(args.dynamic).name);
+      const parsed = toolModuleSchema.safeParse(value);
+      if (!parsed.success) throw new Error(`${args.export} is not a tool`);
+      const tool = parsed.data;
+      const input = await validateSchemaValue({
+        schema: tool.inputSchema,
+        value: args.input,
+        what: "tool input"
+      });
+      const label = isObjectLike(tool.label) ? tool.label : null;
+      const statusLabel = async (callback, values) => {
+        if (callback == null) return void 0;
+        try {
+          const text = string().safeParse(await callback(...values));
+          return text.success ? text.data : void 0;
+        } catch {
+          return void 0;
+        }
+      };
+      const started = await statusLabel(label?.start, [input]);
+      if (started != null) args.onProgress?.(null, started);
+      const result = await tool.execute(input, args.ctx);
+      let output = result;
+      if (isAsyncIterable(result)) {
+        for await (const item of result) {
+          output = item;
+          args.onProgress?.(
+            jsonOf(item, "tool progress"),
+            await statusLabel(label?.delta, [input, item])
+          );
+        }
+      }
+      const validated = await validateSchemaValue({
+        schema: tool.outputSchema,
+        value: output,
+        what: "tool output"
+      });
+      const modelOutput = tool.toModelOutput == null ? null : await tool.toModelOutput(validated);
+      const completed = await statusLabel(label?.complete, [input, validated]);
+      if (completed != null) args.onProgress?.(null, completed);
+      return {
+        output: jsonOf(validated ?? null, "tool output"),
+        modelOutput: modelOutput == null ? null : jsonOf(modelOutput, "tool model output")
+      };
+    },
+    resolveDynamic: async (args) => {
+      const sentinel = lookup(args.export);
+      const parsed = sentinelSchema.safeParse(sentinel);
+      if (!isDynamicSentinel(sentinel) || !parsed.success) {
+        throw new Error(`${args.export} is not a defineDynamic resolver`);
+      }
+      const resolve = parsed.data.events[args.event];
+      if (!isCallable(resolve)) return null;
+      let result;
+      try {
+        result = await resolve(args.payload, args.ctx);
+      } catch (cause) {
+        const request = unopenedRequestOf(cause);
+        if (request == null) throw cause;
+        result = request;
+      }
+      return lowerResolvedValue(result, args.key ?? lastSegment(args.export));
+    },
+    dispatchHook: async (args) => {
+      const handlers = hookHandlersFor(lookup(args.export), args.event);
+      const failures = [];
+      for (const invoke of handlers) {
+        try {
+          await invoke(args.event, args.ctx);
+        } catch (cause) {
+          failures.push({ message: messageOf(cause) });
+        }
+      }
+      return { handled: handlers.length, failures };
+    },
+    handleChannelSocket: async (args) => {
+      const original = channelModuleSchema.safeParse(lookup(args.export));
+      if (!original.success) return null;
+      const parsed = original.data.configure == null ? original : channelModuleSchema.safeParse(await original.data.configure(args.configuration ?? {}));
+      if (!parsed.success) throw new Error(`${args.export} configured channel is invalid`);
+      const route = parsed.data.routes.find(
+        (candidate) => candidate.method === "WS" && matchRoute(candidate.path, args.path)
+      );
+      if (route == null) return null;
+      const response = await route.handler({
+        request: args.request,
+        secrets: args.secrets,
+        receive: args.receive,
+        socket: args.socket
+      });
+      if (response != null && !(response instanceof Response))
+        throw new Error(`${args.export} socket route returned an invalid response`);
+      return response;
+    },
+    handleChannelRoute: async (args) => {
+      const original = channelModuleSchema.safeParse(lookup(args.export));
+      if (!original.success) return null;
+      const parsed = original.data.configure == null ? original : channelModuleSchema.safeParse(await original.data.configure(args.configuration ?? {}));
+      if (!parsed.success) throw new Error(`${args.export} configured channel is invalid`);
+      const route = parsed.data.routes.find(
+        (candidate) => candidate.method === args.request.method && matchRoute(candidate.path, args.path)
+      );
+      if (route == null) return null;
+      const response = await route.handler({
+        request: args.request,
+        secrets: args.secrets,
+        receive: args.receive
+      });
+      if (!(response instanceof Response)) {
+        throw new Error(`${args.export} route ${args.path} did not return a Response`);
+      }
+      return response;
+    }
+  };
+};
+
+export {
+  lowerResolvedValue,
+  combineMcpServers,
+  createIsolateRuntime
+};

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

@@ -0,0 +1,76 @@
+import {
+  _function,
+  array,
+  custom,
+  looseObject,
+  number,
+  object,
+  string,
+  unknown
+} from "./chunk-HGW4YHAY.ts";
+
+// ../agent-provider/src/sandbox/open-scope.ts
+var openRequestFieldsSchema = looseObject({
+  providerName: string(),
+  environmentOptions: unknown(),
+  openOptions: unknown()
+});
+var unopenedSchema = object({
+  unopenedRequest: openRequestFieldsSchema
+});
+var unopenedRequestOf = (cause) => {
+  const parsed = unopenedSchema.safeParse(cause);
+  return parsed.success ? parsed.data.unopenedRequest : null;
+};
+var scopeMethodsSchema = looseObject({ current: _function() });
+var sandboxOpenScopeSchema = custom(
+  (value) => scopeMethodsSchema.safeParse(value).success
+);
+var awaitableOpenRequest = (request) => {
+  const then = (onFulfilled, onRejected) => {
+    const scope = sandboxOpenScopeSchema.safeParse(globalThis.__finalSandboxOpenScope).data;
+    const opener = scope?.current() ?? null;
+    const opened = opener == null ? Promise.reject(
+      Object.assign(
+        new Error(
+          `awaiting ${request.providerName}.open() opens a sandbox only inside a defineSandbox selector`
+        ),
+        { unopenedRequest: { ...request } }
+      )
+    ) : opener(request);
+    return opened.then(onFulfilled, onRejected);
+  };
+  const awaitable = Object.assign(request, { then });
+  Object.defineProperty(awaitable, "then", { enumerable: false });
+  return awaitable;
+};
+var sessionMethodsSchema = looseObject({
+  id: string(),
+  description: string(),
+  defaultWorkingDirectory: string(),
+  ports: array(number()),
+  readFile: _function(),
+  readBinaryFile: _function(),
+  readTextFile: _function(),
+  writeFile: _function(),
+  writeBinaryFile: _function(),
+  writeTextFile: _function(),
+  spawn: _function(),
+  run: _function(),
+  stat: _function(),
+  readDir: _function(),
+  resolvePath: _function(),
+  removePath: _function(),
+  getPortEndpoint: _function(),
+  getPortUrl: _function(),
+  stop: _function(),
+  destroy: _function()
+});
+var sandboxSessionSchema = custom(
+  (value) => sessionMethodsSchema.safeParse(value).success
+);
+
+export {
+  unopenedRequestOf,
+  awaitableOpenRequest
+};