experimental-ash 0.25.2 → 0.27.0

package/dist/src/runtime/connections/principal-context.js

@@ -1,111 +1 @@
-/**
- * Lexically scoped override for the connection principal resolver.
- *
- * `ConnectionPrincipalOverrideStackKey` lets one scope (currently the
- * interactive-OAuth orchestrator) carry an already-resolved
- * {@link ConnectionPrincipal} across a retry that may temporarily
- * run under a different `SessionAuthContext` — for example, the
- * step that resumes from an OAuth webhook sees the unauthenticated
- * callback request as the current caller, not the user who started
- * the turn. Rather than teaching
- * {@link resolveConnectionPrincipal} about every possible
- * restoration quirk, the orchestrator pushes an override frame,
- * runs the retry, and the resolver picks it up.
- *
- * The value is a stack of frames rather than a single map so the
- * push/pop lifecycle is race-safe under concurrent entry within the
- * same ALS scope. Each `withConnectionPrincipalOverride` call owns
- * exactly one frame (identified by object identity) and removes
- * that specific frame on exit regardless of what other frames were
- * pushed or popped while its body was awaited. A naive
- * capture-previous / restore-on-finally pattern would race: if two
- * concurrent calls entered this helper in the same container, both
- * would capture the same `previous`, the last writer would win, and
- * the `finally` blocks would non-deterministically restore to
- * whichever state each happened to observe.
- *
- * Cross-session isolation is handled one layer up by the process
- * `AsyncLocalStorage` in `context/container.ts` — every request runs
- * inside its own `ContextContainer`, so frames never leak between
- * sessions regardless of the in-container stack. The stack only has
- * to handle same-scope concurrency.
- *
- * The key is stored as a **virtual** context value and is never
- * serialized across step boundaries — the durable record is the
- * principal journaled into the step state itself. See D6b in
- * `research/connections/connection-principal-model.md` for the
- * full rationale.
- */
-import { ContextKey } from "#context/key.js";
-/**
- * Context key carrying the stack of in-flight principal override
- * frames. Pushed onto by {@link withConnectionPrincipalOverride};
- * read by {@link lookupConnectionPrincipalOverride}.
- *
- * The stack is ordered oldest-first; callers that want shadowing
- * semantics (inner scopes take precedence over outer) walk the
- * stack from the end backwards.
- */
-export const ConnectionPrincipalOverrideStackKey = new ContextKey("ash.connection-principal-override-stack");
-/**
- * Returns the principal override that should apply to `connectionName`
- * in the current scope, or `undefined` if no scope has pushed one.
- *
- * Walks the override stack from most-recently-pushed to least, so an
- * inner `withConnectionPrincipalOverride` shadows outer frames for
- * the same connection. Returns the override verbatim — callers are
- * responsible for deciding whether to use it in place of a
- * session-derived principal.
- */
-export function lookupConnectionPrincipalOverride(ctx, connectionName) {
-    const stack = ctx?.get(ConnectionPrincipalOverrideStackKey);
-    if (stack === undefined) {
-        return undefined;
-    }
-    for (let i = stack.length - 1; i >= 0; i--) {
-        const frame = stack[i];
-        if (frame === undefined) {
-            continue;
-        }
-        const hit = frame.overrides[connectionName];
-        if (hit !== undefined) {
-            return hit;
-        }
-    }
-    return undefined;
-}
-/**
- * Runs `fn` with the given per-connection principal overrides
- * active on `ctx`.
- *
- * Pushes a new frame onto the override stack on entry and removes
- * that specific frame (by object identity) on exit. Outer frames
- * remain visible to the resolver via
- * {@link lookupConnectionPrincipalOverride}, which walks the stack
- * top-to-bottom so overrides from nested scopes shadow the same
- * connection name in an outer scope.
- *
- * Takes `ctx` as an explicit argument rather than reading from
- * `AsyncLocalStorage`: the helper has to reach `setVirtualContext`,
- * which is intentionally only on the concrete {@link ContextContainer}
- * and not on the public `AshContext` surface. Passing the container
- * in directly keeps the type honest and lets callers thread the
- * already-in-scope container through without an implicit ALS lookup.
- *
- * Safe under concurrent entry on a single container: each call owns
- * exactly one frame and removes it by identity rather than by
- * position, so two racing callers cannot corrupt each other's view
- * of the stack.
- */
-export async function withConnectionPrincipalOverride(ctx, overrides, fn) {
-    const frame = { overrides };
-    const before = ctx.get(ConnectionPrincipalOverrideStackKey) ?? [];
-    ctx.setVirtualContext(ConnectionPrincipalOverrideStackKey, [...before, frame]);
-    try {
-        return await fn();
-    }
-    finally {
-        const current = ctx.get(ConnectionPrincipalOverrideStackKey) ?? [];
-        ctx.setVirtualContext(ConnectionPrincipalOverrideStackKey, current.filter((f) => f !== frame));
-    }
-}
+import{ContextKey}from"#context/key.js";var ConnectionPrincipalOverrideStackKey=new ContextKey(`ash.connection-principal-override-stack`);function lookupConnectionPrincipalOverride(e,n){let r=e?.get(ConnectionPrincipalOverrideStackKey);if(r!==void 0)for(let e=r.length-1;e>=0;e--){let t=r[e];if(t===void 0)continue;let i=t.overrides[n];if(i!==void 0)return i}}async function withConnectionPrincipalOverride(e,n,r){let i={overrides:n},a=e.get(ConnectionPrincipalOverrideStackKey)??[];e.setVirtualContext(ConnectionPrincipalOverrideStackKey,[...a,i]);try{return await r()}finally{let n=e.get(ConnectionPrincipalOverrideStackKey)??[];e.setVirtualContext(ConnectionPrincipalOverrideStackKey,n.filter(e=>e!==i))}}export{ConnectionPrincipalOverrideStackKey,lookupConnectionPrincipalOverride,withConnectionPrincipalOverride};

package/dist/src/runtime/connections/principal.js

@@ -1,106 +1 @@
-/**
- * Principal resolution for connections.
- *
- * This module is the one place the runtime bridges session-layer
- * vocabulary (`"service" | "user" | "runtime" | "unknown"`) to the
- * connection-layer vocabulary (`"app" | "user"`) that connection
- * authors see. Every runtime call site that needs a
- * {@link ConnectionPrincipal} routes through
- * {@link resolveConnectionPrincipal}, and every cache lookup keyed
- * by principal routes through {@link principalKey}.
- */
-import { contextStorage } from "#context/container.js";
-import { AuthKey } from "#context/keys.js";
-import { ConnectionAuthorizationFailedError } from "#public/connections/errors.js";
-import { lookupConnectionPrincipalOverride } from "#runtime/connections/principal-context.js";
-/**
- * Stable string key identifying one principal within a connection's
- * per-principal token cache.
- *
- * - `{ type: "app" }` → `"app"`. Shared across all sessions.
- * - `{ type: "user", issuer, id }` → `"user:${issuer}:${id}"`. The
- *   issuer prefix prevents collisions when the same `id` across
- *   identity providers (for example Slack `U123` vs Google `U123`)
- *   would otherwise alias to the same cache slot.
- */
-export function principalKey(principal) {
-    if (principal.type === "app") {
-        return "app";
-    }
-    return `user:${principal.issuer}:${principal.id}`;
-}
-/**
- * Resolves the {@link ConnectionPrincipal} for one connection.
- *
- * Single entry point for principal resolution — every runtime
- * call site that needs a {@link ConnectionPrincipal} (wrapped tool
- * execution, `startAuthorization` step, `mcp-client` header
- * resolution) routes through here so the decision tree lives in
- * exactly one place.
- *
- * Resolution order:
- *
- * 1. If a context is active and some scope installed a transient
- *    override for `connectionName` via
- *    {@link withConnectionPrincipalOverride}, use it verbatim.
- *    Overrides exist so an in-flight retry can continue to see the
- *    principal that started the flow, even when the current
- *    session auth has rotated (for example during an OAuth
- *    webhook resume).
- * 2. For `authorization.principalType === "app"`, return
- *    `{ type: "app" }` regardless of the session. App-scoped
- *    connections share one credential across all callers and can
- *    be resolved with or without an active context.
- * 3. For `authorization.principalType === "user"`, project the
- *    current caller's {@link SessionAuthContext} (read directly from
- *    the durable {@link AuthKey} seed) into a user principal. A
- *    missing context, an unauthenticated caller, or a non-`"user"`
- *    current principal all fail fast with
- *    `reason: "principal_required"` — no amount of retrying will
- *    recover a misconfigured route, so the runtime does not treat
- *    it as retryable.
- *
- *    {@link AuthKey} is used instead of the derived `SessionKey`
- *    so resolution works in both `runStep` scopes (where
- *    `sessionProvider` has populated `SessionKey`) and durable
- *    `"use step"` boundaries where only the seed keys survive
- *    context serialization. The two are equivalent inside a step
- *    because `sessionProvider` projects `AuthKey` into
- *    `session.auth.current`.
- *
- * `ctx` defaults to {@link contextStorage.getStore}. Pass it
- * explicitly when the caller already has a context handle (for
- * example inside a durable step that deserialized its own
- * {@link AshContext}) to avoid a redundant ALS lookup.
- *
- * The caller is responsible for passing a matching
- * {@link AuthorizationDefinition}. This helper does not validate
- * the definition shape beyond reading `principalType`.
- */
-export function resolveConnectionPrincipal(connectionName, authorization, ctx = contextStorage.getStore()) {
-    const override = lookupConnectionPrincipalOverride(ctx, connectionName);
-    if (override !== undefined) {
-        return override;
-    }
-    if (authorization.principalType === "app") {
-        return { type: "app" };
-    }
-    const current = ctx?.get(AuthKey);
-    if (current === null || current === undefined || current.principalType !== "user") {
-        throw new ConnectionAuthorizationFailedError(connectionName, {
-            message: ctx === undefined
-                ? `Connection "${connectionName}" declares principalType "user" ` +
-                    `but was invoked outside an Ash context, so no user principal can be resolved.`
-                : `Connection "${connectionName}" declares principalType "user" ` +
-                    `but the active session has no authenticated user principal.`,
-            reason: "principal_required",
-            retryable: false,
-        });
-    }
-    return {
-        attributes: current.attributes,
-        id: current.principalId,
-        issuer: current.issuer ?? current.authenticator,
-        type: "user",
-    };
-}
+import{contextStorage}from"#context/container.js";import{AuthKey}from"#context/keys.js";import{ConnectionAuthorizationFailedError}from"#public/connections/errors.js";import{lookupConnectionPrincipalOverride}from"#runtime/connections/principal-context.js";function principalKey(e){return e.type===`app`?`app`:`user:${e.issuer}:${e.id}`}function resolveConnectionPrincipal(t,n,r=contextStorage.getStore()){let i=lookupConnectionPrincipalOverride(r,t);if(i!==void 0)return i;if(n.principalType===`app`)return{type:`app`};let a=r?.get(AuthKey);if(a==null||a.principalType!==`user`)throw new ConnectionAuthorizationFailedError(t,{message:r===void 0?`Connection "${t}" declares principalType "user" but was invoked outside an Ash context, so no user principal can be resolved.`:`Connection "${t}" declares principalType "user" but the active session has no authenticated user principal.`,reason:`principal_required`,retryable:!1});return{attributes:a.attributes,id:a.principalId,issuer:a.issuer??a.authenticator,type:`user`}}export{principalKey,resolveConnectionPrincipal};

package/dist/src/runtime/connections/registry.js

@@ -1,61 +1 @@
-import { McpConnectionClient } from "#runtime/connections/mcp-client.js";
-/**
- * Per-session container mapping connection names to lazily-initialized
- * client wrappers.
- *
- * Currently all connections use MCP, but the registry is protocol-agnostic
- * and will dispatch to the appropriate client type when additional
- * protocols (e.g. OpenAPI) are supported.
- */
-export class ConnectionRegistryImpl {
-    #clients = new Map();
-    #connections;
-    constructor(connections) {
-        this.#connections = connections;
-    }
-    /**
-     * Returns the client for the named connection, creating it on first
-     * access.
-     */
-    getClient(connectionName) {
-        const existing = this.#clients.get(connectionName);
-        if (existing !== undefined) {
-            return existing;
-        }
-        const connection = this.#connections.find((c) => c.connectionName === connectionName);
-        if (connection === undefined) {
-            throw new Error(`Connection "${connectionName}" is not registered.`);
-        }
-        const client = new McpConnectionClient(connection);
-        this.#clients.set(connectionName, client);
-        return client;
-    }
-    /**
-     * Returns the authored approval function for the named connection,
-     * or `undefined` if the connection did not specify one.
-     */
-    getConnectionApproval(connectionName) {
-        const connection = this.#connections.find((c) => c.connectionName === connectionName);
-        return connection?.approval;
-    }
-    /**
-     * Returns all registered connection names.
-     */
-    getConnectionNames() {
-        return this.#connections.map((c) => c.connectionName);
-    }
-    /**
-     * Returns the resolved definitions for all connections.
-     */
-    getConnections() {
-        return this.#connections;
-    }
-    /**
-     * Closes all active client connections.
-     */
-    async dispose() {
-        const closePromises = [...this.#clients.values()].map((client) => client.close());
-        await Promise.allSettled(closePromises);
-        this.#clients.clear();
-    }
-}
+import{McpConnectionClient}from"#runtime/connections/mcp-client.js";var ConnectionRegistryImpl=class{#e=new Map;#t;constructor(e){this.#t=e}getClient(t){let n=this.#e.get(t);if(n!==void 0)return n;let r=this.#t.find(e=>e.connectionName===t);if(r===void 0)throw Error(`Connection "${t}" is not registered.`);let i=new McpConnectionClient(r);return this.#e.set(t,i),i}getConnectionApproval(e){return this.#t.find(t=>t.connectionName===e)?.approval}getConnectionNames(){return this.#t.map(e=>e.connectionName)}getConnections(){return this.#t}async dispose(){let e=[...this.#e.values()].map(e=>e.close());await Promise.allSettled(e),this.#e.clear()}};export{ConnectionRegistryImpl};

package/dist/src/runtime/connections/types.js

@@ -1,41 +1 @@
-/**
- * Protocol-agnostic interfaces for the connection system.
- *
- * Framework tools (`connection_search`) and the context provider
- * depend only on these interfaces, not on any
- * protocol-specific implementation such as MCP.
- */
-/**
- * Defines an interactive authorization strategy with type-safe state
- * flowing from {@link InteractiveAuthorizationDefinition.startAuthorization}
- * to {@link InteractiveAuthorizationDefinition.completeAuthorization}.
- *
- * Defaults `principalType` to `"user"` (the only valid value for
- * interactive authorization in v1).
- *
- * @example
- * ```ts
- * defineInteractiveAuthorization({
- *   getToken: async ({ principal }) => ({ token: cached }),
- *   startAuthorization: async ({ principal, callbackUrl }) => ({
- *     challenge: { url: `https://idp.example/auth?redirect=${callbackUrl}` },
- *     state: { verifier: pkceVerifier },
- *   }),
- *   completeAuthorization: async ({ principal, state, request }) => {
- *     // state is typed as { verifier: string }
- *     const token = await exchange(state.verifier, request);
- *     return { token };
- *   },
- * })
- * ```
- */
-export function defineInteractiveAuthorization(definition) {
-    return { ...definition, principalType: "user" };
-}
-/**
- * Returns whether an authorization definition supports the framework-owned
- * interactive OAuth flow.
- */
-export function supportsInteractiveAuthorization(authorization) {
-    return authorization?.startAuthorization !== undefined;
-}
+function defineInteractiveAuthorization(e){return{...e,principalType:`user`}}function supportsInteractiveAuthorization(e){return e?.startAuthorization!==void 0}export{defineInteractiveAuthorization,supportsInteractiveAuthorization};

package/dist/src/runtime/connections/validate-authorization.js

@@ -1,92 +1 @@
-/**
- * Structural validation for authored connection auth definitions. Returns
- * `undefined` on success or a context-free error fragment for the caller to
- * prefix.
- */
-/**
- * Validates that authored `auth` conforms to the connection auth contract.
- *
- * Returns `undefined` on success; otherwise a descriptive message
- * fragment starting with `The "<fieldName>"...` that the caller is expected
- * to prefix with its own context.
- */
-export function validateAuthorizationSpec(authorization, fieldName = "auth") {
-    if (authorization === null || typeof authorization !== "object") {
-        return `The "${fieldName}" field must be an object with a "getToken" method.`;
-    }
-    const auth = authorization;
-    if (typeof auth.getToken !== "function") {
-        return `The "${fieldName}.getToken" field must be a function returning Promise<{ token }>.`;
-    }
-    const hasStart = auth.startAuthorization !== undefined;
-    const hasComplete = auth.completeAuthorization !== undefined;
-    if (!hasStart && !hasComplete && auth.principalType !== undefined) {
-        if (auth.principalType !== "app" && auth.principalType !== "user") {
-            return `The "${fieldName}.principalType" field must be "app" or "user".`;
-        }
-    }
-    if (hasStart !== hasComplete) {
-        return `The "${fieldName}" field must provide either both "startAuthorization" and "completeAuthorization" (interactive OAuth) or neither (getToken-only). Got only "${hasStart ? "startAuthorization" : "completeAuthorization"}".`;
-    }
-    if (hasStart && typeof auth.startAuthorization !== "function") {
-        return `The "${fieldName}.startAuthorization" field must be a function when provided.`;
-    }
-    if (hasComplete && typeof auth.completeAuthorization !== "function") {
-        return `The "${fieldName}.completeAuthorization" field must be a function when provided.`;
-    }
-    if (hasStart && auth.principalType !== "user") {
-        return `Interactive authorization (startAuthorization + completeAuthorization) is restricted to "principalType": "user" in v1. See D10 of research/connections/connection-principal-model.md for the rationale.`;
-    }
-    return undefined;
-}
-/**
- * Validates and normalizes an authored auth definition into the runtime shape.
- *
- * `getToken`-only auth defaults to `principalType: "app"` so static tokens and
- * custom bearer-token fetchers do not need extra boilerplate.
- */
-export function normalizeAuthorizationSpec(authorization, prefix, fieldName = "auth") {
-    const message = validateAuthorizationSpec(authorization, fieldName);
-    if (message !== undefined) {
-        throw new Error(`${prefix} ${message}`);
-    }
-    const auth = authorization;
-    const vercelConnect = extractVercelConnectMarker(auth.vercelConnect);
-    if (auth.startAuthorization !== undefined && auth.completeAuthorization !== undefined) {
-        const interactive = {
-            completeAuthorization: auth.completeAuthorization,
-            getToken: auth.getToken,
-            principalType: "user",
-            startAuthorization: auth.startAuthorization,
-        };
-        return vercelConnect === undefined ? interactive : { ...interactive, vercelConnect };
-    }
-    const nonInteractive = {
-        getToken: auth.getToken,
-        principalType: (auth.principalType ??
-            "app"),
-    };
-    return vercelConnect === undefined ? nonInteractive : { ...nonInteractive, vercelConnect };
-}
-/**
- * Reads the optional `vercelConnect: { connector: string }` marker
- * attached by `@vercel/connect/ash`'s `connect()` helper. Returns the
- * parsed marker when present and well-formed, otherwise `undefined`.
- *
- * The marker is opaque to the runtime — it exists so downstream tooling
- * (eg. the Ash compiler / Vercel dashboard) can attribute the auth
- * back to a Vercel Connect connector without inspecting `getToken`'s
- * closure state. Validation is lenient (a malformed marker is dropped,
- * not thrown) so a misbehaving auth provider can't fail an otherwise-
- * valid connection.
- */
-function extractVercelConnectMarker(value) {
-    if (value === null || typeof value !== "object") {
-        return undefined;
-    }
-    const connector = value.connector;
-    if (typeof connector !== "string" || connector.length === 0) {
-        return undefined;
-    }
-    return { connector };
-}
+function validateAuthorizationSpec(e,t=`auth`){if(typeof e!=`object`||!e)return`The "${t}" field must be an object with a "getToken" method.`;let n=e;if(typeof n.getToken!=`function`)return`The "${t}.getToken" field must be a function returning Promise<{ token }>.`;let r=n.startAuthorization!==void 0,i=n.completeAuthorization!==void 0;if(!r&&!i&&n.principalType!==void 0&&n.principalType!==`app`&&n.principalType!==`user`)return`The "${t}.principalType" field must be "app" or "user".`;if(r!==i)return`The "${t}" field must provide either both "startAuthorization" and "completeAuthorization" (interactive OAuth) or neither (getToken-only). Got only "${r?`startAuthorization`:`completeAuthorization`}".`;if(r&&typeof n.startAuthorization!=`function`)return`The "${t}.startAuthorization" field must be a function when provided.`;if(i&&typeof n.completeAuthorization!=`function`)return`The "${t}.completeAuthorization" field must be a function when provided.`;if(r&&n.principalType!==`user`)return`Interactive authorization (startAuthorization + completeAuthorization) is restricted to "principalType": "user" in v1. See D10 of research/connections/connection-principal-model.md for the rationale.`}function normalizeAuthorizationSpec(e,t,n=`auth`){let r=validateAuthorizationSpec(e,n);if(r!==void 0)throw Error(`${t} ${r}`);let i=e,a=extractVercelConnectMarker(i.vercelConnect);if(i.startAuthorization!==void 0&&i.completeAuthorization!==void 0){let e={completeAuthorization:i.completeAuthorization,getToken:i.getToken,principalType:`user`,startAuthorization:i.startAuthorization};return a===void 0?e:{...e,vercelConnect:a}}let o={getToken:i.getToken,principalType:i.principalType??`app`};return a===void 0?o:{...o,vercelConnect:a}}function extractVercelConnectMarker(e){if(typeof e!=`object`||!e)return;let t=e.connector;if(!(typeof t!=`string`||t.length===0))return{connector:t}}export{normalizeAuthorizationSpec,validateAuthorizationSpec};

package/dist/src/runtime/framework-channels/index.js

@@ -1,38 +1 @@
-import { none, vercelOidc } from "#public/channels/auth.js";
-import { ashChannel } from "#public/channels/ash.js";
-import { getConnectionCallbackChannelDefinitions, getConnectionCallbackChannelNames, } from "#runtime/connections/callback-route.js";
-import { getSessionCallbackChannelDefinitions, getSessionCallbackChannelNames, } from "#runtime/session-callback-route.js";
-const ASH_CHANNEL_NAME = "ash";
-export function getFrameworkChannelDefinitions() {
-    const auth = resolveFrameworkAshAuth();
-    const compiled = ashChannel({ auth });
-    const result = [];
-    for (const route of compiled.routes) {
-        result.push({
-            name: ASH_CHANNEL_NAME,
-            method: route.method.toUpperCase(),
-            urlPath: route.path,
-            fetch: async (req, ctx) => route.handler(req, ctx),
-            handler: route.handler,
-            adapter: compiled.adapter,
-            logicalPath: `framework://channels/${route.path}`,
-            sourceId: `ash:framework:${route.method.toLowerCase()}-${route.path}`,
-            sourceKind: "module",
-        });
-    }
-    result.push(...getConnectionCallbackChannelDefinitions(), ...getSessionCallbackChannelDefinitions());
-    return result;
-}
-export function getAllFrameworkChannelNames() {
-    return new Set([
-        ASH_CHANNEL_NAME,
-        ...getConnectionCallbackChannelNames(),
-        ...getSessionCallbackChannelNames(),
-    ]);
-}
-function resolveFrameworkAshAuth() {
-    if (process.env.VERCEL) {
-        return vercelOidc();
-    }
-    return none();
-}
+import{none,vercelOidc}from"#public/channels/auth.js";import{ashChannel}from"#public/channels/ash.js";import{getConnectionCallbackChannelDefinitions,getConnectionCallbackChannelNames}from"#runtime/connections/callback-route.js";import{getSessionCallbackChannelDefinitions,getSessionCallbackChannelNames}from"#runtime/session-callback-route.js";var ASH_CHANNEL_NAME=`ash`;function getFrameworkChannelDefinitions(){let e=ashChannel({auth:resolveFrameworkAshAuth()}),t=[];for(let n of e.routes)t.push({name:ASH_CHANNEL_NAME,method:n.method.toUpperCase(),urlPath:n.path,fetch:async(e,t)=>n.handler(e,t),handler:n.handler,adapter:e.adapter,logicalPath:`framework://channels/${n.path}`,sourceId:`ash:framework:${n.method.toLowerCase()}-${n.path}`,sourceKind:`module`});return t.push(...getConnectionCallbackChannelDefinitions(),...getSessionCallbackChannelDefinitions()),t}function getAllFrameworkChannelNames(){return new Set([ASH_CHANNEL_NAME,...getConnectionCallbackChannelNames(),...getSessionCallbackChannelNames()])}function resolveFrameworkAshAuth(){return process.env.VERCEL?vercelOidc():none()}export{getAllFrameworkChannelNames,getFrameworkChannelDefinitions};

package/dist/src/runtime/framework-tools/ask-question.js

@@ -1,30 +1 @@
-import { z } from "#compiled/zod/index.js";
-import { inputRequestSchema } from "#runtime/input/types.js";
-/**
- * Stable model-visible name for the framework question tool.
- */
-export const ASK_QUESTION_TOOL_NAME = "ask_question";
-const askQuestionToolInputSchema = inputRequestSchema.omit({
-    action: true,
-    display: true,
-    requestId: true,
-});
-const { $schema: _jsonSchemaVersion, ...askQuestionInputSchema } = z.toJSONSchema(askQuestionToolInputSchema);
-/**
- * Shared input schema used by the framework `ask_question` tool.
- */
-export const ASK_QUESTION_INPUT_SCHEMA = askQuestionInputSchema;
-/**
- * Root-only framework tool that lets the agent request structured user input.
- *
- * This is a client-side tool (as indicated by it not having an `execute` method). It requires user input
- * and therefore cannot be autonomously executed by the runtime.
- */
-export const ASK_QUESTION_TOOL_DEFINITION = {
-    description: "Ask the user a question and wait for their response before continuing. Use this when you need clarification or a choice from the user.",
-    inputSchema: ASK_QUESTION_INPUT_SCHEMA,
-    logicalPath: "ash:framework/ask-question",
-    name: ASK_QUESTION_TOOL_NAME,
-    sourceId: "ash:ask-question-tool",
-    sourceKind: "module",
-};
+import{z}from"#compiled/zod/index.js";import{inputRequestSchema}from"#runtime/input/types.js";var ASK_QUESTION_TOOL_NAME=`ask_question`,askQuestionToolInputSchema=inputRequestSchema.omit({action:!0,display:!0,requestId:!0}),{$schema:_jsonSchemaVersion,...askQuestionInputSchema}=z.toJSONSchema(askQuestionToolInputSchema),ASK_QUESTION_INPUT_SCHEMA=askQuestionInputSchema,ASK_QUESTION_TOOL_DEFINITION={description:`Ask the user a question and wait for their response before continuing. Use this when you need clarification or a choice from the user.`,inputSchema:ASK_QUESTION_INPUT_SCHEMA,logicalPath:`ash:framework/ask-question`,name:ASK_QUESTION_TOOL_NAME,sourceId:`ash:ask-question-tool`,sourceKind:`module`};export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_TOOL_DEFINITION,ASK_QUESTION_TOOL_NAME};

package/dist/src/runtime/framework-tools/bash.js

@@ -1,40 +1 @@
-import { executeBashOnSandbox } from "#execution/sandbox/bash-tool.js";
-/**
- * Shared input schema used by the framework `bash` tool and any author tool
- * constructed via {@link defineBashTool}.
- *
- * Exported so the public `defineBashTool` factory and the framework
- * `BASH_TOOL_DEFINITION` use the exact same schema object — keeping model
- * input contracts in sync without duplication.
- */
-export const BASH_INPUT_SCHEMA = {
-    additionalProperties: false,
-    properties: {
-        command: {
-            description: "The shell command to execute.",
-            type: "string",
-        },
-    },
-    required: ["command"],
-    type: "object",
-};
-/**
- * Framework-owned executors stay statically imported so hosted server bundles
- * can trace and rewrite them into deployable output chunks.
- *
- * These modules are only used by the Nitro-hosted runtime path. Their deeper
- * sandbox dependencies remain lazily loaded inside the execution layer, so the
- * top-level import here does not force those backends to initialize eagerly.
- */
-async function executeBash(input) {
-    return executeBashOnSandbox(input);
-}
-export const BASH_TOOL_DEFINITION = {
-    description: "Execute a shell command in the shared workspace environment.",
-    execute: executeBash,
-    inputSchema: BASH_INPUT_SCHEMA,
-    logicalPath: "ash:framework/bash",
-    name: "bash",
-    sourceId: "ash:bash-tool",
-    sourceKind: "module",
-};
+import{executeBashOnSandbox}from"#execution/sandbox/bash-tool.js";var BASH_INPUT_SCHEMA={additionalProperties:!1,properties:{command:{description:`The shell command to execute.`,type:`string`}},required:[`command`],type:`object`};async function executeBash(e){return executeBashOnSandbox(e)}var BASH_TOOL_DEFINITION={description:`Execute a shell command in the shared workspace environment.`,execute:executeBash,inputSchema:BASH_INPUT_SCHEMA,logicalPath:`ash:framework/bash`,name:`bash`,sourceId:`ash:bash-tool`,sourceKind:`module`};export{BASH_INPUT_SCHEMA,BASH_TOOL_DEFINITION};