@abot-ai/runtime 1.0.0

package/dist/src/capabilities/tool-event-metadata.d.ts

@@ -0,0 +1,8 @@
+import type { ToolActionSummary, ToolCall, ToolDefinition, ToolEventMetadata, ToolExecutionResult } from "./tool-types.js";
+export declare function buildToolLifecycleEventCopy(definition: ToolDefinition | undefined, phase: "started" | "completed" | "failed"): Readonly<{
+    status: string;
+    message: string;
+}> | undefined;
+export declare function buildToolCompletedEventActions(call: ToolCall, result: ToolExecutionResult, definition?: ToolDefinition): ToolActionSummary[];
+export declare function buildToolStartEventMetadata(call: ToolCall, definition?: ToolDefinition): ToolEventMetadata | undefined;
+export declare function buildToolCompletedEventMetadata(call: ToolCall, result: ToolExecutionResult, definition?: ToolDefinition): ToolEventMetadata | undefined;

package/dist/src/capabilities/tool-event-metadata.js

@@ -0,0 +1,181 @@
+function safeTrim(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function truncate(value, maxLength = 500) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function asPlainRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function compactMeta(value) {
+    const entries = Object.entries(value).filter(([, item]) => item !== undefined);
+    if (entries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(entries);
+}
+function readStringParam(params, key) {
+    const value = safeTrim(params[key]);
+    if (!value) {
+        return undefined;
+    }
+    return truncate(value);
+}
+function readNumberParam(params, key) {
+    const value = params[key];
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function readStringArrayParam(params, key) {
+    const value = params[key];
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const strings = value
+        .filter((item) => typeof item === "string")
+        .map((item) => safeTrim(item))
+        .filter((item) => item.length > 0)
+        .map((item) => truncate(item));
+    return strings.length > 0 ? strings : undefined;
+}
+function summarizeParamValue(value) {
+    if (typeof value === "string") {
+        return `string(len=${value.length})`;
+    }
+    if (typeof value === "number" ||
+        typeof value === "boolean" ||
+        value === null) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return `array(len=${value.length})`;
+    }
+    if (value && typeof value === "object") {
+        return `object(keys=${Object.keys(value)
+            .sort()
+            .join(",")})`;
+    }
+    return String(value);
+}
+function summarizeParams(params) {
+    const entries = Object.keys(params)
+        .sort()
+        .map((key) => [key, summarizeParamValue(params[key])]);
+    if (entries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(entries);
+}
+function uniqueActionTypes(actions) {
+    if (!Array.isArray(actions) || actions.length === 0) {
+        return undefined;
+    }
+    const types = [
+        ...new Set(actions.map((action) => action.type).filter(Boolean)),
+    ];
+    return types.length > 0 ? types : undefined;
+}
+function uniqueTargets(actions) {
+    if (!Array.isArray(actions) || actions.length === 0) {
+        return undefined;
+    }
+    const targets = [
+        ...new Set(actions
+            .map((action) => safeTrim(action.target))
+            .filter((target) => target.length > 0)),
+    ];
+    return targets.length > 0 ? targets : undefined;
+}
+function buildDeclaredCallMeta(call, definition) {
+    const projections = definition?.eventPresentation?.metadata;
+    if (!projections)
+        return undefined;
+    const values = Object.fromEntries(Object.entries(projections).flatMap(([key, projection]) => {
+        let value;
+        switch (projection.kind) {
+            case "string":
+                value = readStringParam(call.params, projection.param);
+                break;
+            case "number":
+                value = readNumberParam(call.params, projection.param);
+                break;
+            case "string_array":
+                value = readStringArrayParam(call.params, projection.param);
+                break;
+            case "length":
+                {
+                    const raw = call.params[projection.param];
+                    value = typeof raw === "string" ? raw.length : undefined;
+                }
+                break;
+        }
+        const resolved = value ?? projection.default;
+        return resolved === undefined ? [] : [[key, resolved]];
+    }));
+    return compactMeta(values);
+}
+export function buildToolLifecycleEventCopy(definition, phase) {
+    return definition?.eventPresentation?.lifecycle?.[phase];
+}
+function buildCallMeta(call, definition) {
+    const declared = buildDeclaredCallMeta(call, definition);
+    if (declared)
+        return declared;
+    const params = summarizeParams(call.params);
+    return params ? { params } : undefined;
+}
+function buildResultMeta(result, actions) {
+    const data = result.data || {};
+    const actionTypes = uniqueActionTypes(actions);
+    const targets = uniqueTargets(actions);
+    return compactMeta({
+        ...(typeof result.exitCode === "number"
+            ? { exitCode: result.exitCode }
+            : {}),
+        ...(typeof result.errorCode === "string" &&
+            result.errorCode.trim().length > 0
+            ? { errorCode: result.errorCode.trim() }
+            : {}),
+        ...(typeof data.hasData === "boolean" ? { hasData: data.hasData } : {}),
+        ...(typeof data.itemCount === "number"
+            ? { itemCount: data.itemCount }
+            : {}),
+        ...(typeof data.mutationEvidence === "boolean"
+            ? { mutationEvidence: data.mutationEvidence }
+            : {}),
+        ...(typeof data.currentStateEvidence === "boolean"
+            ? { currentStateEvidence: data.currentStateEvidence }
+            : {}),
+        ...(typeof data.stateAlreadySatisfied === "boolean"
+            ? { stateAlreadySatisfied: data.stateAlreadySatisfied }
+            : {}),
+        ...(actionTypes ? { actionTypes } : {}),
+        ...(targets ? { targets } : {}),
+    });
+}
+export function buildToolCompletedEventActions(call, result, definition) {
+    const logicalTarget = safeTrim(buildCallMeta(call, definition)?.path);
+    return (result.actions ?? []).map((action) => ({
+        type: action.type,
+        ...(logicalTarget ? { target: logicalTarget } : {}),
+    }));
+}
+export function buildToolStartEventMetadata(call, definition) {
+    return buildCallMeta(call, definition);
+}
+export function buildToolCompletedEventMetadata(call, result, definition) {
+    const toolResultData = asPlainRecord(result.data?.eventMeta) || {};
+    const actions = buildToolCompletedEventActions(call, result, definition);
+    return compactMeta({
+        ...(buildCallMeta(call, definition) || {}),
+        ...toolResultData,
+        ...(buildResultMeta(result, actions) || {}),
+    });
+}

package/dist/src/capabilities/tool-executor.d.ts

@@ -0,0 +1,10 @@
+import type { ToolCall, ToolExecutionContext, ToolExecutionResult, ToolImplementation } from "./tool-types.js";
+type ToolExecutorOptions = {
+    implementations?: Record<string, ToolImplementation>;
+    abortSignal?: AbortSignal;
+    sharedState?: ToolExecutionContext["sharedState"];
+    modelInvoker?: ToolExecutionContext["modelInvoker"];
+    runtimePathResolver?: ToolExecutionContext["runtimePathResolver"];
+};
+export declare function executeToolCall(call: ToolCall, options?: ToolExecutorOptions): Promise<ToolExecutionResult>;
+export {};

package/dist/src/capabilities/tool-executor.js

@@ -0,0 +1,160 @@
+import { traceDebug } from "../runtime/observability/debug-logger.js";
+function normalizeImplementationOutput(value) {
+    if (typeof value !== "object" ||
+        value === null ||
+        Array.isArray(value) ||
+        typeof value.ok !== "boolean" ||
+        typeof value.output !== "string" ||
+        typeof value.producedNewInformation !== "boolean") {
+        const error = new TypeError("tool implementations must return ok, output, and producedNewInformation");
+        error.code = "tool_result_invalid";
+        throw error;
+    }
+    const output = value.output;
+    return {
+        ok: value.ok,
+        output,
+        progress: value.progress === true,
+        producedNewInformation: value.producedNewInformation === true,
+        actions: Array.isArray(value.actions) ? value.actions : undefined,
+        exitCode: typeof value.exitCode === "number" ? value.exitCode : undefined,
+        stdout: typeof value.stdout === "string" ? value.stdout : undefined,
+        stderr: typeof value.stderr === "string" ? value.stderr : undefined,
+        data: value.data,
+        error: typeof value.error === "string" ? value.error : undefined,
+        errorCode: typeof value.errorCode === "string" ? value.errorCode : undefined,
+    };
+}
+function finalizeToolExecutionResult(result) {
+    const progress = result.ok ? result.progress : false;
+    const producedNewInformation = result.ok
+        ? result.producedNewInformation
+        : false;
+    const actions = result.actions ?? [];
+    traceDebug("tools.tool-executor", "tool.progress.signal", {
+        tool: result.tool,
+        progress,
+        producedNewInformation,
+        actionCount: actions.length,
+        actionTypes: actions.map((action) => action.type),
+        outputLength: result.output.length,
+    });
+    return {
+        ...result,
+        progress,
+        producedNewInformation,
+    };
+}
+function createToolAbortError(reason) {
+    const message = reason instanceof Error
+        ? reason.message
+        : typeof reason === "string" && reason.trim().length > 0
+            ? reason
+            : "tool execution aborted";
+    const error = new Error(message);
+    error.name = "AbortError";
+    return error;
+}
+function isAbortLikeError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+async function raceWithAbort(execution, signal) {
+    let abortListener;
+    const aborted = new Promise((_, reject) => {
+        const onAbort = () => reject(createToolAbortError(signal.reason));
+        if (signal.aborted) {
+            onAbort();
+            return;
+        }
+        abortListener = onAbort;
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+        return await Promise.race([execution, aborted]);
+    }
+    finally {
+        if (abortListener) {
+            signal.removeEventListener("abort", abortListener);
+        }
+    }
+}
+export async function executeToolCall(call, options = {}) {
+    const implementations = options.implementations ?? {};
+    const execute = implementations[call.tool];
+    if (!execute) {
+        return finalizeToolExecutionResult({
+            ok: false,
+            tool: call.tool,
+            output: `Tool ${call.tool} not implemented`,
+            progress: false,
+            producedNewInformation: false,
+            error: "not_implemented",
+            errorCode: "not_implemented",
+        });
+    }
+    try {
+        if (options.abortSignal?.aborted) {
+            throw createToolAbortError(options.abortSignal.reason);
+        }
+        const execution = execute(call.params, {
+            abortSignal: options.abortSignal,
+            sharedState: options.sharedState,
+            modelInvoker: options.modelInvoker,
+            runtimePathResolver: options.runtimePathResolver,
+        });
+        const rawOutput = options.abortSignal
+            ? await raceWithAbort(execution, options.abortSignal)
+            : await execution;
+        const normalized = normalizeImplementationOutput(rawOutput);
+        return finalizeToolExecutionResult({
+            ok: normalized.ok,
+            tool: call.tool,
+            output: normalized.output,
+            progress: normalized.progress,
+            producedNewInformation: normalized.producedNewInformation,
+            ...(normalized.actions ? { actions: normalized.actions } : {}),
+            ...(typeof normalized.exitCode === "number"
+                ? { exitCode: normalized.exitCode }
+                : {}),
+            ...(typeof normalized.stdout === "string"
+                ? { stdout: normalized.stdout }
+                : {}),
+            ...(typeof normalized.stderr === "string"
+                ? { stderr: normalized.stderr }
+                : {}),
+            ...(normalized.data ? { data: normalized.data } : {}),
+            ...(normalized.error ? { error: normalized.error } : {}),
+            ...(normalized.errorCode ? { errorCode: normalized.errorCode } : {}),
+        });
+    }
+    catch (error) {
+        if (options.abortSignal?.aborted || isAbortLikeError(error)) {
+            return finalizeToolExecutionResult({
+                ok: false,
+                tool: call.tool,
+                output: "tool execution aborted",
+                progress: false,
+                producedNewInformation: false,
+                error: "tool execution aborted",
+                errorCode: "request_aborted",
+            });
+        }
+        const message = error?.message || "tool execution failed";
+        const code = typeof error?.code === "string" && error.code.trim()
+            ? error.code
+            : "tool_execution_failed";
+        const data = error?.data && typeof error.data === "object"
+            ? error.data
+            : undefined;
+        return finalizeToolExecutionResult({
+            ok: false,
+            tool: call.tool,
+            output: message,
+            progress: false,
+            producedNewInformation: false,
+            error: message,
+            errorCode: code,
+            ...(data ? { data } : {}),
+        });
+    }
+}

package/dist/src/capabilities/tool-types.d.ts

@@ -0,0 +1,287 @@
+import type { ModelStep } from "../shared/types.js";
+import type { RuntimeAttachmentKind } from "../shared/attachments.js";
+import type { ToolNormalInvocationContract } from "./normal-invocation/contracts.js";
+export type { ToolNormalInvocationApproval, ToolNormalInvocationArrayInput, ToolNormalInvocationBooleanInput, ToolNormalInvocationBoundedStringInput, ToolNormalInvocationContract, ToolNormalInvocationEnumInput, ToolNormalInvocationEffect, ToolNormalInvocationFixedValue, ToolNormalInvocationInput, ToolNormalInvocationInputValidation, ToolNormalInvocationNumberInput, ToolNormalInvocationOperation, ToolNormalInvocationPayload, ToolNormalInvocationPropertyInput, ToolNormalInvocationScalarInput, ToolNormalInvocationUnboundedStringInput, } from "./normal-invocation/contracts.js";
+export type ToolRoutingCapability = "filesystem_inspection" | "filesystem_mutation" | "semantic_lookup" | "semantic_mutation" | "web_lookup";
+export type ToolDevelopmentRole = "inspect" | "establish" | "mutate" | "verify" | "auxiliary";
+export declare const TOOL_CATALOG_GROUP_ID_MAX_LENGTH = 128;
+export type ToolCatalogGroup = string;
+export declare function isToolCatalogGroupId(input: unknown): input is ToolCatalogGroup;
+export type ToolExecutionEffect = "read_only" | "mutating" | "mixed";
+export type ToolControlsRefinement = "mechanical_when_complete";
+export type ToolEventMetadataProjection = Readonly<{
+    param: string;
+    kind: "string" | "number" | "string_array" | "length";
+    default?: string | number | boolean;
+}>;
+export type ToolEventLifecycleCopy = Readonly<{
+    status: string;
+    message: string;
+}>;
+export type ToolEventPresentation = Readonly<{
+    metadata: Readonly<Record<string, ToolEventMetadataProjection>>;
+    lifecycle?: Readonly<{
+        started?: ToolEventLifecycleCopy;
+        completed?: ToolEventLifecycleCopy;
+        failed?: ToolEventLifecycleCopy;
+    }>;
+}>;
+export type ToolParamsByCommand = {
+    discriminator: string;
+    variants: Record<string, Record<string, string>>;
+};
+export type ToolPayloadChannelSpec = {
+    params: string[];
+    outputParam: string;
+    generationMode: "raw_text";
+    targetParam?: string;
+    targetRole?: "payload_body" | "operation_target";
+    contextScope?: "standard" | "target_only" | "target_with_artifacts";
+    targetContext?: "bounded" | "full" | "full_numbered";
+    responseFormat?: "json" | Record<string, unknown>;
+    promptHint?: string;
+    stages?: ToolPayloadChannelStageSpec[];
+    groundingWindow?: number;
+    requiresCurrentTargetObservation?: {
+        targetParam: string;
+        contentRequirement?: "any" | "full";
+    };
+};
+export declare const TOOL_PAYLOAD_STAGE_LITERAL_OUTPUT_MAX_BYTES = 4096;
+export type ToolPayloadChannelStageSpec = {
+    outputParam: string;
+    contextScope?: "standard" | "target_only" | "target_with_artifacts";
+    targetContext?: "bounded" | "full" | "full_numbered";
+    responseFormat?: "json" | Record<string, unknown>;
+    targetLineBoundProperties?: string[];
+    promptHint?: string;
+    includeMaterializedParams?: string[];
+    minBytes?: number;
+    minBytesOverride?: ToolPayloadChannelStageMinBytesOverride;
+    literalOutput?: ToolPayloadChannelStageLiteralOutput;
+};
+export type ToolPayloadChannelStageMinBytesOverride = Readonly<{
+    materializedParam: string;
+    property: string;
+    equals: string;
+    minBytes: number;
+}>;
+export type ToolPayloadChannelStageLiteralOutput = Readonly<{
+    when: Readonly<{
+        materializedParam: string;
+        property: string;
+        equals: string;
+    }>;
+    value: string;
+}>;
+export type ToolRuntimePathBinding = Readonly<{
+    operationId: string;
+    param: string;
+    base: "worker_working_directory";
+    default?: ".";
+}>;
+export type ToolDefinition = {
+    name: string;
+    description?: string;
+    routingCapability: ToolRoutingCapability;
+    controlsRefinement?: ToolControlsRefinement;
+    catalogGroups?: ToolCatalogGroup[];
+    executionEffect?: ToolExecutionEffect;
+    developmentRoles?: ToolDevelopmentRole[];
+    eventPresentation?: ToolEventPresentation;
+    params: Record<string, string>;
+    paramsByCommand?: ToolParamsByCommand;
+    payloadChannelSpec?: ToolPayloadChannelSpec;
+    runtimePathBindings?: ToolRuntimePathBinding[];
+};
+export type CanonicalToolDefinitionDeclaration = Omit<ToolDefinition, "params" | "executionEffect"> & {
+    params?: never;
+    executionEffect?: never;
+};
+export type ToolDefinitionDeclaration = CanonicalToolDefinitionDeclaration;
+export type ToolExecutionRequestContext = Readonly<{
+    agentMode: "fast" | "reasoning" | "deep";
+    toolPermissionMode: "ask" | "full_access";
+    modelPreference?: Readonly<{
+        profileId: string;
+        scope?: "main" | "all";
+    }>;
+}>;
+export type ToolRequestAttachment = Readonly<{
+    id: string;
+    kind: RuntimeAttachmentKind;
+    mimeType: string;
+    absolutePath: string;
+    name?: string;
+    size?: number;
+}>;
+/** Minimal config-filtered tool fact projected to plugin execution only. */
+export type ToolAvailabilityEntry = Readonly<{
+    toolName: string;
+    operationId: string;
+    summary: string;
+    catalogGroups: readonly ToolCatalogGroup[];
+    effect: ToolExecutionEffect;
+}>;
+export type ToolExecutionSharedState = {
+    activeDirectory?: string;
+    currentSessionId?: string;
+    requestContext?: ToolExecutionRequestContext;
+    requestAttachments?: readonly ToolRequestAttachment[];
+    /** Read-only request-effective catalog; never projected to a model directly. */
+    availableTools?: readonly ToolAvailabilityEntry[];
+    runtimePaths?: {
+        rootDir?: string;
+        runtimeDir?: string;
+        agentWorkDir?: string;
+        sessionsDir?: string;
+        workspaceDir?: string;
+        sharedDir?: string;
+        compiledDir?: string;
+        traceFile?: string;
+    };
+};
+export type RuntimeToolPathLocation = "agent_work" | "workspace" | "runtime_root"
+/** Explicit opt-in for read-only tools that inspect arbitrary host paths. */
+ | "host_system";
+export type RuntimeToolPathErrorCode = "runtime_tool_path_required" | "runtime_tool_path_null_byte" | "runtime_tool_path_location_required" | "runtime_tool_path_root_unavailable" | "runtime_tool_path_workspace_unavailable" | "runtime_tool_path_outside_configured_roots" | "runtime_tool_path_symlink_escape" | "runtime_tool_path_canonicalization_failed" | "runtime_tool_path_traversal" | "runtime_tool_path_outside_working_directory";
+export type RuntimeToolPathError = TypeError & Readonly<{
+    code: RuntimeToolPathErrorCode;
+}>;
+export type ResolvedRuntimeToolPath = Readonly<{
+    location: RuntimeToolPathLocation;
+    rootPath: string;
+    absolutePath: string;
+    relativePath: string;
+    logicalPath: string;
+}>;
+export type RuntimeToolPathResolver = Readonly<{
+    resolve(rawPath: unknown, options?: Readonly<{
+        defaultPath?: string;
+        requirePath?: boolean;
+        allowedLocations?: readonly RuntimeToolPathLocation[];
+    }>): ResolvedRuntimeToolPath;
+}>;
+export type ToolModelInvoker = Readonly<{
+    invokeText(input: Readonly<{
+        modelStep: ModelStep;
+        instructions?: string;
+        prompt: string;
+        timeoutReason: string;
+        format?: "json" | Record<string, unknown>;
+    }>): Promise<string>;
+}>;
+export type ToolExecutionContext = {
+    abortSignal?: AbortSignal;
+    sharedState?: ToolExecutionSharedState;
+    /** Runtime-owned path interpretation and containment authority. */
+    runtimePathResolver?: RuntimeToolPathResolver;
+    /** Trusted request-bound service for tools whose own implementation uses a model. */
+    modelInvoker?: ToolModelInvoker;
+};
+export type ToolImplementation = (params: Record<string, unknown>, context?: ToolExecutionContext) => Promise<ToolImplementationOutput>;
+export type ToolCallAdapterInput = {
+    tool: string;
+    params: Record<string, unknown>;
+};
+export type ToolCallAdapter = {
+    normalizeCall?: (input: ToolCallAdapterInput) => ToolCall;
+    validateCall?: (input: ToolCallAdapterInput) => {
+        error: string;
+        repairHint?: string;
+    } | null;
+};
+export type ToolModule = {
+    definition: ToolDefinition;
+    implementation: ToolImplementation;
+    adapter?: ToolCallAdapter;
+    normalInvocation: ToolNormalInvocationContract;
+};
+type ToolModuleDeclarationBase = Omit<ToolModule, "definition" | "normalInvocation">;
+export type ToolModuleDeclaration = ToolModuleDeclarationBase & {
+    definition: CanonicalToolDefinitionDeclaration;
+    normalInvocation: ToolNormalInvocationContract;
+};
+export type RegisteredToolNormalInvocation = Readonly<{
+    toolName: string;
+    definition: ToolDefinition;
+    contract: ToolNormalInvocationContract;
+    adapter?: ToolCallAdapter;
+}>;
+export type ToolCall = {
+    tool: string;
+    params: Record<string, unknown>;
+    clientStatus?: string;
+};
+export type ToolActionSummary = {
+    type: string;
+    target?: string;
+    details?: string;
+};
+export type ToolObservationKind = "stable_fact" | "volatile_external" | "task_result";
+export type ToolObservationCarryPolicy = "always" | "never";
+export type AuthoritativePlannedWorkTaskResultRole = "authoritative_project_handoff" | "authoritative_planned_work_handoff_v1";
+export type ToolObservationTaskResultRole = AuthoritativePlannedWorkTaskResultRole | "supplemental_follow_up";
+export type ToolObservationMeta = {
+    kind: ToolObservationKind;
+    carryPolicy: ToolObservationCarryPolicy;
+    taskResultRole?: ToolObservationTaskResultRole;
+};
+export type ToolEventMetadata = {
+    [key: string]: unknown;
+};
+export type ParsedToolCall = {
+    ok: true;
+    call: ToolCall;
+} | {
+    ok: false;
+    error: string;
+    repairHint?: string;
+};
+export type ToolExecutionResult = {
+    ok: boolean;
+    tool: string;
+    output: string;
+    progress?: boolean;
+    producedNewInformation: boolean;
+    actions?: ToolActionSummary[];
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    data?: {
+        hasData?: boolean;
+        itemCount?: number;
+        mutationEvidence?: boolean;
+        mutationGrounding?: string;
+        currentStateEvidence?: boolean;
+        stateAlreadySatisfied?: boolean;
+        observationMeta?: ToolObservationMeta;
+        eventMeta?: ToolEventMetadata;
+        [key: string]: unknown;
+    };
+    error?: string;
+    errorCode?: string;
+};
+export type ToolImplementationOutput = {
+    ok: boolean;
+    output: string;
+    progress?: boolean;
+    producedNewInformation: boolean;
+    actions?: ToolActionSummary[];
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    data?: {
+        hasData?: boolean;
+        itemCount?: number;
+        mutationEvidence?: boolean;
+        mutationGrounding?: string;
+        currentStateEvidence?: boolean;
+        stateAlreadySatisfied?: boolean;
+        observationMeta?: ToolObservationMeta;
+        eventMeta?: ToolEventMetadata;
+        [key: string]: unknown;
+    };
+    error?: string;
+    errorCode?: string;
+};

package/dist/src/capabilities/tool-types.js

@@ -0,0 +1,8 @@
+export const TOOL_CATALOG_GROUP_ID_MAX_LENGTH = 128;
+export function isToolCatalogGroupId(input) {
+    return (typeof input === "string" &&
+        input.length > 0 &&
+        input.length <= TOOL_CATALOG_GROUP_ID_MAX_LENGTH &&
+        /^[a-z0-9][a-z0-9._-]*$/u.test(input));
+}
+export const TOOL_PAYLOAD_STAGE_LITERAL_OUTPUT_MAX_BYTES = 4_096;

package/dist/src/cli/abot.d.ts

@@ -0,0 +1 @@
+export declare function runAbotCli(argv?: string[]): Promise<void>;