@sentry/junior 0.197.0 → 0.199.0

package/dist/chat/runtime/turn.d.ts

@@ -1,77 +0,0 @@
-import type { ThreadConversationState } from "@/chat/state/conversation";
-import type { ConversationTurnFailureCode } from "@/chat/conversations/history";
-export { buildDeterministicTurnId } from "@/chat/state/turn-id";
-/** Classified Slack turn failure carrying the owning Sentry capture outward. */
-export declare class ConversationTurnBoundaryError extends Error {
-    readonly eventId?: string;
-    readonly failureCode: ConversationTurnFailureCode;
-    constructor(args: {
-        cause: unknown;
-        eventId?: string;
-        failureCode: ConversationTurnFailureCode;
-    });
-}
-/** Return a classified Slack boundary failure without erasing its cause. */
-export declare function getConversationTurnBoundaryError(error: unknown): ConversationTurnBoundaryError | undefined;
-/**
- * Queue-worker yield routing: respond.ts returns a suspended AgentRunOutcome
- * and the Slack executor raises this at the worker boundary so the lease owner
- * requeues the conversation.
- */
-export declare class CooperativeTurnYieldError extends Error {
-    readonly code = "cooperative_turn_yield";
-    constructor(message?: string);
-}
-export declare function isCooperativeTurnYieldError(error: unknown): error is CooperativeTurnYieldError;
-/** Error indicating durable turn input could not be committed by the worker owner. */
-export declare class TurnInputCommitLostError extends Error {
-    readonly code = "turn_input_commit_lost";
-    constructor(message?: string);
-}
-/** Return whether an error means the durable worker lost input ownership. */
-export declare function isTurnInputCommitLostError(error: unknown): error is TurnInputCommitLostError;
-/** Error indicating durable turn input should stay pending for a later worker. */
-export declare class TurnInputDeferredError extends Error {
-    readonly code = "turn_input_deferred";
-    constructor(message?: string);
-}
-/** Return whether an error means the durable worker should redeliver input later. */
-export declare function isTurnInputDeferredError(error: unknown): error is TurnInputDeferredError;
-/** Mark a turn as the active turn in conversation state. */
-export declare function startActiveTurn(args: {
-    conversation: ThreadConversationState;
-    nextTurnId: string;
-}): void;
-/**
- * Close the active turn without marking a Pi session reusable for future
- * history. Use this for auth handoffs and recovery replies that end the live
- * turn but do not produce a completed Pi session.
- */
-export declare function markTurnClosed(args: {
-    conversation: ThreadConversationState;
-    nowMs: number;
-    sessionId?: string;
-}): void;
-/**
- * Mark a turn as completed after its assistant output has been handled.
- */
-export declare function markTurnCompleted(args: {
-    conversation: ThreadConversationState;
-    nowMs: number;
-    sessionId: string;
-}): void;
-/**
- * Mark a turn as failed when execution or final user-visible reply delivery
- * cannot be completed. If `sessionId` is provided, `activeTurnId` is only
- * cleared when it still matches the failing turn.
- */
-export declare function markTurnFailed(args: {
-    conversation: ThreadConversationState;
-    nowMs: number;
-    sessionId?: string;
-    userMessageId?: string;
-    markConversationMessage: (conversation: ThreadConversationState, messageId: string | undefined, patch: {
-        replied?: boolean;
-        skippedReason?: string;
-    }) => void;
-}): void;

package/dist/chat/sandbox/command-result.d.ts

@@ -1,74 +0,0 @@
-import type { SandboxEgressAuthRequiredSignal, SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress/session";
-export interface SandboxCommandOutcome {
-    ok: boolean;
-    command: string;
-    cwd: string;
-    exit_code: number;
-    signal: null;
-    timed_out: boolean;
-    aborted?: boolean;
-    stdout: string;
-    stderr: string;
-    stdout_truncated: boolean;
-    stderr_truncated: boolean;
-    auth_required?: SandboxEgressAuthRequiredSignal;
-    permission_denied?: SandboxEgressPermissionDeniedSignal;
-}
-/** Format one shell command outcome as Junior's structured tool result. */
-export declare function formatSandboxCommandResult(params: SandboxCommandOutcome): import("@/chat/tool-support/structured-result").JuniorTextToolOutputEnvelope<{
-    permission_denied?: {
-        grant: {
-            access: "read" | "write";
-            name: string;
-            leaseScope?: string | undefined;
-            reason?: string | undefined;
-            requirements?: string[] | undefined;
-        };
-        message: string;
-        provider: string;
-        source: "upstream";
-        status: number;
-        upstreamHost: string;
-        upstreamPath: string;
-        createdAtMs: number;
-        account?: {
-            id: string;
-            displayName?: string | undefined;
-            handle?: string | undefined;
-            label?: string | undefined;
-            url?: string | undefined;
-        } | undefined;
-        acceptedPermissions?: string | undefined;
-        sso?: string | undefined;
-    } | undefined;
-    auth_required?: {
-        grant: {
-            access: "read" | "write";
-            name: string;
-            leaseScope?: string | undefined;
-            reason?: string | undefined;
-            requirements?: string[] | undefined;
-        };
-        kind: "unavailable" | "auth_required";
-        provider: string;
-        createdAtMs: number;
-        authorization?: {
-            provider: string;
-            type: "oauth";
-            scope?: string | undefined;
-        } | undefined;
-        message?: string | undefined;
-    } | undefined;
-    target: string;
-    truncated: boolean;
-    command: string;
-    cwd: string;
-    exit_code: number;
-    signal: null;
-    timed_out: boolean;
-    aborted: boolean;
-    stdout: string;
-    stderr: string;
-    stdout_truncated: boolean;
-    stderr_truncated: boolean;
-}>;

package/dist/chat/sandbox/credentials.d.ts

@@ -1,11 +0,0 @@
-interface VercelSandboxCredentials {
-    teamId: string;
-    projectId: string;
-    token: string;
-}
-/**
- * Resolve explicit Vercel Sandbox credentials, or return undefined to let
- * the SDK read ambient Vercel auth from its own environment detection.
- */
-export declare function getVercelSandboxCredentials(): VercelSandboxCredentials | undefined;
-export {};

package/dist/chat/sandbox/docker.d.ts

@@ -1,17 +0,0 @@
-import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
-/** Docker daemon config for Vercel sandbox guests (nested containers). */
-export declare const DOCKER_DAEMON_JSON = "{\n  \"storage-driver\": \"overlay2\",\n  \"live-restore\": false\n}\n";
-/**
- * Start dockerd when the socket is missing and wait until `docker info` works.
- * Re-execs through sudo so the sandbox user can call it without root.
- */
-export declare const DOCKER_ENSURE_SCRIPT = "#!/bin/sh\nset -eu\n\nif [ \"$(id -u)\" -ne 0 ]; then\n  exec sudo -n \"$0\" \"$@\"\nfi\n\nSOCK=/var/run/docker.sock\nPIDFILE=/var/run/docker.pid\nLOG=/var/log/junior-dockerd.log\n\nis_ready() {\n  [ -S \"$SOCK\" ] && /usr/bin/docker info >/dev/null 2>&1\n}\n\nif is_ready; then\n  chmod 666 \"$SOCK\" 2>/dev/null || true\n  exit 0\nfi\n\nmkdir -p /etc/docker /var/lib/docker /var/run /var/log\nif [ ! -f /etc/docker/daemon.json ]; then\n  cat > /etc/docker/daemon.json <<'EOF'\n{\n  \"storage-driver\": \"overlay2\",\n  \"live-restore\": false\n}\nEOF\nfi\n\nif [ -f \"$PIDFILE\" ]; then\n  oldpid=\"$(cat \"$PIDFILE\" 2>/dev/null || true)\"\n  if [ -n \"${oldpid:-}\" ] && ! kill -0 \"$oldpid\" 2>/dev/null; then\n    rm -f \"$PIDFILE\"\n  fi\nfi\n\nif [ ! -f \"$PIDFILE\" ] || ! kill -0 \"$(cat \"$PIDFILE\" 2>/dev/null)\" 2>/dev/null; then\n  # dockerd must outlive this helper; nohup + background is intentional.\n  nohup dockerd --host=\"unix://$SOCK\" --pidfile=\"$PIDFILE\" >\"$LOG\" 2>&1 &\nfi\n\ni=0\nwhile [ \"$i\" -lt 50 ]; do\n  if is_ready; then\n    chmod 666 \"$SOCK\" 2>/dev/null || true\n    exit 0\n  fi\n  i=$((i + 1))\n  sleep 0.1\ndone\n\necho \"junior-ensure-docker: dockerd failed to become ready\" >&2\nif [ -f \"$LOG\" ]; then\n  tail -n 50 \"$LOG\" >&2 || true\nfi\nexit 1\n";
-/** PATH wrapper so plain `docker` starts the daemon on first use. */
-export declare const DOCKER_CLI_WRAPPER_SCRIPT = "#!/bin/sh\nset -eu\nif command -v junior-ensure-docker >/dev/null 2>&1; then\n  junior-ensure-docker\nfi\nexec /usr/bin/docker \"$@\"\n";
-/** PATH wrapper so plain `docker-compose` starts the daemon on first use. */
-export declare const DOCKER_COMPOSE_CLI_WRAPPER_SCRIPT = "#!/bin/sh\nset -eu\nif command -v junior-ensure-docker >/dev/null 2>&1; then\n  junior-ensure-docker\nfi\nexec /usr/local/libexec/junior-docker-compose \"$@\"\n";
-/**
- * Best-effort dockerd start during sandbox prepare.
- * Missing helper is a no-op so tests and base sandboxes stay green.
- */
-export declare function ensureDockerDaemon(sandbox: Pick<SandboxWorkspace, "runCommand">, signal?: AbortSignal): Promise<void>;

package/dist/chat/sandbox/egress/credentials.d.ts

@@ -1,61 +0,0 @@
-import type { PluginAuthorization, PluginGrant } from "@sentry/junior-plugin-api";
-import { type SandboxEgressCredentialContext, type SandboxEgressCredentialLease } from "@/chat/sandbox/egress/session";
-/** Describes whether grant selection came from plugin hooks or the broker default. */
-export type SandboxEgressGrantSelection = {
-    grant: PluginGrant;
-    source: "plugin";
-} | {
-    grant: PluginGrant;
-    source: "broker";
-};
-export type SandboxEgressCredentialErrorKind = "auth_required" | "unavailable";
-/**
- * Signals that egress selected a grant but could not issue credential headers.
- *
- * Callers convert this into command-level auth-required state so the agent can
- * request authorization without exposing provider-specific lease internals.
- */
-export declare class SandboxEgressCredentialError extends Error {
-    readonly authorization?: PluginAuthorization;
-    readonly grant: PluginGrant;
-    readonly kind: SandboxEgressCredentialErrorKind;
-    readonly provider: string;
-    constructor(input: {
-        authorization?: PluginAuthorization;
-        grant: PluginGrant;
-        kind: SandboxEgressCredentialErrorKind;
-        message: string;
-        provider: string;
-    });
-}
-/**
- * Select the grant needed for one outbound request.
- *
- * GitHub GraphQL and other plugin-owned APIs may need body-aware grant choices;
- * providers without hooks use a simple read/write default based on HTTP method.
- */
-export declare function selectSandboxEgressGrant(input: {
-    bodyText?: string;
-    method: string;
-    operation?: string;
-    provider: string;
-    upstreamUrl: URL;
-}): Promise<SandboxEgressGrantSelection>;
-/**
- * Resolve the authorization flow attached to a broker-selected egress grant.
- *
- * Plugin-selected grants can return their own authorization metadata when
- * issuing credentials; broker defaults use the provider OAuth config.
- */
-export declare function authorizationForSandboxEgressGrant(provider: string, selection: SandboxEgressGrantSelection): PluginAuthorization | undefined;
-/**
- * Return credential header transforms for a selected grant.
- *
- * Only shared installation grants are remembered on the host. User and other
- * grants always issue from the live credential source so a saved login change
- * cannot leave stale auth headers in place. The sandbox context only authorizes
- * the request.
- */
-export declare function sandboxEgressCredentialLease(provider: string, selection: SandboxEgressGrantSelection, context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease>;
-/** Return whether a credential lease can modify requests to the target host. */
-export declare function hasSandboxEgressLeaseTransformForHost(lease: SandboxEgressCredentialLease, host: string): boolean;

package/dist/chat/sandbox/egress/oidc.d.ts

@@ -1,3 +0,0 @@
-import { type JWTPayload } from "jose";
-/** Verify Vercel signed this Sandbox firewall proxy request for the active VM session. */
-export declare function verifyVercelSandboxOidcToken(token: string): Promise<JWTPayload>;

package/dist/chat/sandbox/egress/policy.d.ts

@@ -1,32 +0,0 @@
-import type { NetworkPolicy } from "@vercel/sandbox";
-import type { TracePropagationHeaders } from "@/chat/logging";
-import { type SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
-/** Return whether an outbound host is covered by a provider domain rule. */
-export declare function matchesSandboxEgressDomain(host: string, domain: string): boolean;
-/**
- * Resolve the plugin provider responsible for an outbound sandbox host.
- *
- * Only plugin-declared provider domains are eligible for credentialed sandbox
- * egress. Hosts without a matching provider are blocked by the proxy even if a
- * malformed or stale network policy tried to forward them.
- */
-export declare function resolveSandboxEgressProviderForHost(host: string): string | undefined;
-/**
- * Build the policy that forwards provider domains through the egress proxy.
- *
- * The signed credential token is embedded in the forward URL so the proxy can
- * bind each forwarded request back to the actor and sandbox VM that created the
- * command. The sandbox receives placeholder env vars, not provider credentials.
- */
-export declare function buildSandboxEgressNetworkPolicy(input?: {
-    credentialToken?: string;
-    traceConfig?: SandboxEgressTracePropagationConfig;
-    traceHeaders?: TracePropagationHeaders;
-}): NetworkPolicy;
-/**
- * Resolve non-secret command environment values for registered sandbox providers.
- *
- * Credential env vars are placeholders that tell tools which auth variable name
- * exists; real credential headers are issued lazily by host egress.
- */
-export declare function resolveSandboxCommandEnvironment(): Promise<Record<string, string>>;

package/dist/chat/sandbox/egress/proxy.d.ts

@@ -1,35 +0,0 @@
-import { type CredentialedEgressHttpInterceptor } from "@/chat/egress/credentialed";
-import { type SandboxEgressTracePropagationConfig } from "@/chat/sandbox/egress/tracing";
-import type { JWTPayload } from "jose";
-/**
- * Intercepts a verified sandbox HTTP request before live provider forwarding.
- *
- * The hook runs after OIDC, forwarded URL validation, provider ownership, and
- * credential-context checks have succeeded.
- */
-export type SandboxEgressHttpInterceptor = CredentialedEgressHttpInterceptor;
-/** Runtime dependencies for the sandbox egress proxy boundary. */
-interface ProxyDeps {
-    fetch?: typeof fetch;
-    interceptHttp?: SandboxEgressHttpInterceptor;
-    tracePropagation?: SandboxEgressTracePropagationConfig;
-    verifyOidc?: (token: string) => Promise<JWTPayload>;
-}
-/**
- * Return whether a request carries the forwarding headers expected from Vercel.
- *
- * This is only a cheap classifier for routing into the proxy handler. Real
- * authentication happens in `proxySandboxEgressRequest` by verifying the OIDC
- * token and signed Junior credential context.
- */
-export declare function isSandboxEgressForwardedRequest(request: Request): boolean;
-/**
- * Handle one forwarded sandbox egress request.
- *
- * This is the public proxy boundary: it rejects unauthenticated VM requests,
- * rejects forwarded URLs outside plugin-owned provider domains, rejects signed
- * credential contexts that do not match the active VM id, and only then asks
- * `execute.ts` to issue credentials and contact the upstream provider.
- */
-export declare function proxySandboxEgressRequest(request: Request, deps?: ProxyDeps): Promise<Response>;
-export {};

package/dist/chat/sandbox/egress/schemas.d.ts

@@ -1,187 +0,0 @@
-import { z } from "zod";
-export declare const sandboxEgressGrantSchema: z.ZodObject<{
-    access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
-    leaseScope: z.ZodOptional<z.ZodString>;
-    name: z.ZodString;
-    reason: z.ZodOptional<z.ZodString>;
-    requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export declare const sandboxEgressCredentialContextSchema: z.ZodObject<{
-    credentials: z.ZodUnion<readonly [z.ZodObject<{
-        actor: z.ZodObject<{
-            type: z.ZodLiteral<"user">;
-            userId: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>, z.ZodObject<{
-        actor: z.ZodObject<{
-            platform: z.ZodLiteral<"system">;
-            name: z.ZodString;
-        }, z.core.$strict>;
-        subject: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"user">;
-            userId: z.ZodString;
-            allowedWhen: z.ZodLiteral<"private-direct-conversation">;
-            binding: z.ZodObject<{
-                type: z.ZodLiteral<"slack-direct-conversation">;
-                teamId: z.ZodString;
-                channelId: z.ZodString;
-                signature: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"user">;
-            userId: z.ZodString;
-            allowedWhen: z.ZodLiteral<"scheduled-task">;
-            taskId: z.ZodString;
-            binding: z.ZodObject<{
-                type: z.ZodLiteral<"scheduled-task">;
-                plugin: z.ZodString;
-                taskId: z.ZodString;
-                signature: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"user">;
-            userId: z.ZodString;
-            allowedWhen: z.ZodLiteral<"event-task">;
-            taskId: z.ZodString;
-            binding: z.ZodObject<{
-                type: z.ZodLiteral<"event-task">;
-                plugin: z.ZodString;
-                taskId: z.ZodString;
-                signature: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>], "allowedWhen">>;
-    }, z.core.$strict>]>;
-    egressId: z.ZodString;
-    expiresAtMs: z.ZodNumber;
-    contextId: z.ZodString;
-}, z.core.$strict>;
-export declare const sandboxEgressCredentialLeaseSchema: z.ZodObject<{
-    account: z.ZodOptional<z.ZodObject<{
-        displayName: z.ZodOptional<z.ZodString>;
-        handle: z.ZodOptional<z.ZodString>;
-        id: z.ZodString;
-        label: z.ZodOptional<z.ZodString>;
-        url: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    authorization: z.ZodOptional<z.ZodObject<{
-        provider: z.ZodString;
-        scope: z.ZodOptional<z.ZodString>;
-        type: z.ZodLiteral<"oauth">;
-    }, z.core.$strict>>;
-    grant: z.ZodObject<{
-        access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
-        leaseScope: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
-    provider: z.ZodString;
-    expiresAt: z.ZodString;
-    headerTransforms: z.ZodArray<z.ZodObject<{
-        domain: z.ZodString;
-        headers: z.ZodRecord<z.ZodString, z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const sandboxEgressAuthRequiredSignalSchema: z.ZodObject<{
-    authorization: z.ZodOptional<z.ZodObject<{
-        provider: z.ZodString;
-        scope: z.ZodOptional<z.ZodString>;
-        type: z.ZodLiteral<"oauth">;
-    }, z.core.$strict>>;
-    grant: z.ZodObject<{
-        access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
-        leaseScope: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
-    kind: z.ZodDefault<z.ZodEnum<{
-        unavailable: "unavailable";
-        auth_required: "auth_required";
-    }>>;
-    provider: z.ZodString;
-    message: z.ZodOptional<z.ZodString>;
-    createdAtMs: z.ZodNumber;
-}, z.core.$strict>;
-export declare const sandboxEgressPermissionDeniedSignalSchema: z.ZodObject<{
-    account: z.ZodOptional<z.ZodObject<{
-        displayName: z.ZodOptional<z.ZodString>;
-        handle: z.ZodOptional<z.ZodString>;
-        id: z.ZodString;
-        label: z.ZodOptional<z.ZodString>;
-        url: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    acceptedPermissions: z.ZodOptional<z.ZodString>;
-    grant: z.ZodObject<{
-        access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
-        leaseScope: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-        requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
-    message: z.ZodString;
-    provider: z.ZodString;
-    source: z.ZodLiteral<"upstream">;
-    sso: z.ZodOptional<z.ZodString>;
-    status: z.ZodNumber;
-    upstreamHost: z.ZodString;
-    upstreamPath: z.ZodString;
-    createdAtMs: z.ZodNumber;
-}, z.core.$strict>;
-export declare const sandboxEgressSignalsResponseSchema: z.ZodObject<{
-    auth_required: z.ZodOptional<z.ZodObject<{
-        authorization: z.ZodOptional<z.ZodObject<{
-            provider: z.ZodString;
-            scope: z.ZodOptional<z.ZodString>;
-            type: z.ZodLiteral<"oauth">;
-        }, z.core.$strict>>;
-        grant: z.ZodObject<{
-            access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
-            leaseScope: z.ZodOptional<z.ZodString>;
-            name: z.ZodString;
-            reason: z.ZodOptional<z.ZodString>;
-            requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-        kind: z.ZodDefault<z.ZodEnum<{
-            unavailable: "unavailable";
-            auth_required: "auth_required";
-        }>>;
-        provider: z.ZodString;
-        message: z.ZodOptional<z.ZodString>;
-        createdAtMs: z.ZodNumber;
-    }, z.core.$strict>>;
-    permission_denied: z.ZodOptional<z.ZodObject<{
-        account: z.ZodOptional<z.ZodObject<{
-            displayName: z.ZodOptional<z.ZodString>;
-            handle: z.ZodOptional<z.ZodString>;
-            id: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
-            url: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        acceptedPermissions: z.ZodOptional<z.ZodString>;
-        grant: z.ZodObject<{
-            access: z.ZodUnion<readonly [z.ZodLiteral<"read">, z.ZodLiteral<"write">]>;
-            leaseScope: z.ZodOptional<z.ZodString>;
-            name: z.ZodString;
-            reason: z.ZodOptional<z.ZodString>;
-            requirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>;
-        message: z.ZodString;
-        provider: z.ZodString;
-        source: z.ZodLiteral<"upstream">;
-        sso: z.ZodOptional<z.ZodString>;
-        status: z.ZodNumber;
-        upstreamHost: z.ZodString;
-        upstreamPath: z.ZodString;
-        createdAtMs: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type SandboxEgressCredentialContext = z.output<typeof sandboxEgressCredentialContextSchema>;
-export type SandboxEgressGrant = z.output<typeof sandboxEgressGrantSchema>;
-export type SandboxEgressCredentialLease = z.output<typeof sandboxEgressCredentialLeaseSchema>;
-export type SandboxEgressAuthRequiredSignal = z.output<typeof sandboxEgressAuthRequiredSignalSchema>;
-export type SandboxEgressPermissionDeniedSignal = z.output<typeof sandboxEgressPermissionDeniedSignalSchema>;
-/** Parse a host-owned sandbox egress auth signal from state or tool results. */
-export declare function parseSandboxEgressAuthRequiredSignal(value: unknown): SandboxEgressAuthRequiredSignal | undefined;
-/** Parse a host-owned sandbox egress permission-denied signal from state or tool results. */
-export declare function parseSandboxEgressPermissionDeniedSignal(value: unknown): SandboxEgressPermissionDeniedSignal | undefined;

package/dist/chat/sandbox/egress/session.d.ts

@@ -1,59 +0,0 @@
-import type { CredentialContext } from "@/chat/credentials/context";
-import { type SandboxEgressAuthRequiredSignal, type SandboxEgressCredentialContext, type SandboxEgressCredentialLease, type SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress/schemas";
-export declare const SANDBOX_EGRESS_PROXY_PATH = "/api/internal/sandbox-egress";
-export type { SandboxEgressAuthRequiredSignal, SandboxEgressCredentialContext, SandboxEgressCredentialLease, SandboxEgressPermissionDeniedSignal, };
-/**
- * Create the signed Junior credential context embedded in the proxy URL.
- *
- * The token binds actor credentials to a specific sandbox egress id and a
- * short expiry. Vercel OIDC proves which VM sent a request; this token proves
- * which Junior actor and credential context that VM is allowed to use.
- */
-export declare function createSandboxEgressCredentialToken(input: {
-    credentials: CredentialContext;
-    egressId: string;
-    ttlMs?: number;
-}): string;
-/**
- * Verify the signed Junior credential context from the proxy URL.
- *
- * Returning `undefined` means the token is missing, expired, malformed, or not
- * signed with the current `JUNIOR_SECRET`.
- */
-export declare function parseSandboxEgressCredentialToken(token: string | undefined): SandboxEgressCredentialContext | undefined;
-/**
- * Remember auth headers for a shared installation grant.
- *
- * User and other grants are ignored here. TTL follows the provider expiry.
- * Sandbox context expiry still decides whether a request may use the headers;
- * it does not shorten a shared installation grant for other sandboxes.
- */
-export declare function setSandboxEgressCredentialLease(_context: SandboxEgressCredentialContext, lease: SandboxEgressCredentialLease): Promise<void>;
-/** Load remembered auth headers for a shared installation grant. */
-export declare function getSandboxEgressCredentialLease(provider: string, grant: SandboxEgressCredentialLease["grant"], _context: SandboxEgressCredentialContext): Promise<SandboxEgressCredentialLease | undefined>;
-/** Drop remembered installation headers after the upstream rejects them. */
-export declare function clearSandboxEgressCredentialLease(provider: string, grant: SandboxEgressCredentialLease["grant"], _context: SandboxEgressCredentialContext): Promise<void>;
-/**
- * Record that credential issuance needs user authorization for this command.
- *
- * The command runner consumes this after the sandbox tool finishes so the agent
- * can present a normal authorization-required response instead of a raw proxy
- * failure.
- */
-export declare function setSandboxEgressAuthRequiredSignal(context: SandboxEgressCredentialContext, signal: Omit<SandboxEgressAuthRequiredSignal, "createdAtMs" | "kind"> & {
-    kind?: SandboxEgressAuthRequiredSignal["kind"];
-}): Promise<void>;
-/**
- * Record that the provider rejected an issued credential with permission denial.
- */
-export declare function setSandboxEgressPermissionDeniedSignal(context: SandboxEgressCredentialContext, signal: Omit<SandboxEgressPermissionDeniedSignal, "createdAtMs">): Promise<void>;
-/** Remove pending auth/permission signals before or after a sandbox command. */
-export declare function clearSandboxEgressSignals(egressId: string | undefined): Promise<void>;
-/**
- * Consume the auth signal produced during a sandbox command, preferring writes.
- */
-export declare function consumeSandboxEgressAuthRequiredSignal(egressId: string | undefined): Promise<SandboxEgressAuthRequiredSignal | undefined>;
-/**
- * Consume the permission signal produced during a sandbox command, preferring writes.
- */
-export declare function consumeSandboxEgressPermissionDeniedSignal(egressId: string | undefined): Promise<SandboxEgressPermissionDeniedSignal | undefined>;

package/dist/chat/sandbox/egress/signals.d.ts

@@ -1,9 +0,0 @@
-import type { SandboxEgressAuthRequiredSignal, SandboxEgressPermissionDeniedSignal } from "@/chat/sandbox/egress/schemas";
-/** Authenticated transport for signal state owned by another Junior process. */
-export interface SandboxEgressSignalTransport {
-    clear: (credentialToken: string) => Promise<void>;
-    consume: (credentialToken: string) => Promise<{
-        authRequired?: SandboxEgressAuthRequiredSignal;
-        permissionDenied?: SandboxEgressPermissionDeniedSignal;
-    }>;
-}

package/dist/chat/sandbox/egress/tracing.d.ts

@@ -1,7 +0,0 @@
-export interface SandboxEgressTracePropagationConfig {
-    domains?: string[];
-}
-/** Normalize exact and leading-wildcard sandbox egress trace domains. */
-export declare function normalizeSandboxEgressTracePropagationDomains(domains: string[] | undefined): string[];
-/** Return whether a host may carry sandbox egress trace propagation headers. */
-export declare function shouldPropagateSandboxEgressTrace(host: string, config?: SandboxEgressTracePropagationConfig): boolean;

package/dist/chat/sandbox/errors.d.ts

@@ -1,18 +0,0 @@
-/** Detect sandbox filesystem operations that can safely ignore existing directories. */
-export declare function isAlreadyExistsError(error: unknown): boolean;
-/** Detect when the current sandbox session is unavailable and must be reacquired. */
-export declare function isSandboxUnavailableError(error: unknown): boolean;
-/** Detect a durable sandbox reference that can no longer be restored. */
-export declare function isSandboxMissingError(error: unknown): boolean;
-/** Detect transient snapshot boot races so sandbox creation can retry. */
-export declare function isSnapshottingError(error: unknown): boolean;
-/** Detect cancellation so a durable builder stays available for check-in. */
-export declare function isAbortError(error: unknown): boolean;
-/** Detect transient Vercel Sandbox API failures that keep a job resumable. */
-export declare function isSandboxApiTransientError(error: unknown): boolean;
-/** Detect interrupted command streams where no reliable exit status is available. */
-export declare function isSandboxCommandStreamInterruptedError(error: unknown): boolean;
-/** Wrap setup failures. Keep WorkspaceSnapshotNotReadyError as-is. */
-export declare function wrapSandboxSetupError(error: unknown): Error;
-/** Record span data and throw one stable sandbox operation error. */
-export declare function throwSandboxOperationError(action: string, error: unknown, includeMissingPath?: boolean): never;

package/dist/chat/sandbox/http-error-details.d.ts

@@ -1,18 +0,0 @@
-interface ExtraFieldOption {
-    sourceKey: string;
-    attributeKey: string;
-    summaryKey?: string;
-}
-export interface ExtractHttpErrorDetailsOptions {
-    attributePrefix?: string;
-    previewLimit?: number;
-    extraFields?: ExtraFieldOption[];
-}
-export interface ExtractedHttpErrorDetails {
-    attributes: Record<string, string | number | boolean | string[]>;
-    summary: string;
-    searchableText: string;
-}
-/** Extract structured HTTP error metadata (status, headers, body preview) for logging. */
-export declare function extractHttpErrorDetails(error: unknown, options?: ExtractHttpErrorDetailsOptions): ExtractedHttpErrorDetails;
-export {};

package/dist/chat/sandbox/noninteractive-command.d.ts

@@ -1,21 +0,0 @@
-import type { SandboxCommandResult, SandboxWorkspace } from "@/chat/sandbox/workspace";
-interface NonInteractiveShellOptions {
-    env?: Record<string, string>;
-    pathPrefix?: string;
-}
-interface NonInteractiveCommandInput extends NonInteractiveShellOptions {
-    args?: string[];
-    cmd: string;
-    cwd?: string;
-    login?: boolean;
-    signal?: AbortSignal;
-    sudo?: boolean;
-    timeoutMs?: number;
-}
-/** Render one argv command as a safely quoted shell script. */
-export declare function buildCommandScript(input: Pick<NonInteractiveCommandInput, "args" | "cmd">): string;
-/** Build one shell entrypoint that never waits on terminal input. */
-export declare function buildNonInteractiveShellScript(script: string, options?: NonInteractiveShellOptions): string;
-/** Run a subprocess through one enforced non-interactive entrypoint. */
-export declare function runNonInteractiveCommand(sandbox: Pick<SandboxWorkspace, "runCommand">, input: NonInteractiveCommandInput): Promise<SandboxCommandResult>;
-export {};

package/dist/chat/sandbox/paths.d.ts

@@ -1,8 +0,0 @@
-export declare const SANDBOX_WORKSPACE_ROOT: string;
-export declare const SANDBOX_REPOS_ROOT: string;
-export declare const SANDBOX_SKILLS_ROOT: string;
-export declare const SANDBOX_DATA_ROOT: string;
-export declare function sandboxSkillDir(skillName: string): string;
-export declare function sandboxSkillFile(skillName: string): string;
-/** Explain how the agent should resolve files and commands owned by a skill. */
-export declare function sandboxSkillPathResolution(skillName: string): string;