@sentry/junior 0.198.0 → 0.199.0

package/dist/chat/tasks/execution-stats.d.ts

@@ -1,105 +0,0 @@
-import { type TaskExecutionStatus } from "@/db/schema/task-executions";
-export declare const TASK_EXECUTION_TYPES: readonly ["scheduled", "event"];
-export declare const TASK_EXECUTION_STATUSES: readonly ["blocked", "completed", "failed"];
-export type TaskExecutionType = (typeof TASK_EXECUTION_TYPES)[number];
-export type TaskExecutionDay = {
-    costUsd: number;
-    date: string;
-    event: number;
-    scheduled: number;
-};
-export type TaskRunWindows = {
-    1: number;
-    7: number;
-    30: number;
-    90: number;
-};
-export type TaskExecutionSummary = {
-    lastConversationId?: string;
-    lastExecutedAtMs?: number;
-    runs: TaskRunWindows;
-    totalRuns: number;
-};
-/** Empty run windows for tasks with no execution history. */
-export declare function emptyTaskRunWindows(): TaskRunWindows;
-export type TaskExecutionRecord = {
-    conversationId?: string;
-    costUsd?: number;
-    durationMs?: number;
-    executedAt: string;
-    executionId: string;
-    status: TaskExecutionStatus;
-    title?: string;
-    totalTokens?: number;
-};
-export type TaskRunRecord = TaskExecutionRecord & {
-    kind: TaskExecutionType;
-    taskId: string;
-};
-export type TaskExecutionStatusDay = {
-    blocked: number;
-    completed: number;
-    date: string;
-    failed: number;
-};
-/** Record one terminal task execution and its durable conversation when present. */
-export declare function recordTaskExecution(type: TaskExecutionType, taskId: string, options: {
-    conversationId?: string;
-    executionId: string;
-    namespace?: string;
-    nowMs?: number;
-    status?: TaskExecutionStatus;
-}): Promise<void>;
-/** Load usage analytics for all tasks of one type and namespace. */
-export declare function readTaskExecutionSummaries(type: TaskExecutionType, namespace: string, options?: {
-    nowMs?: number;
-}): Promise<Map<string, TaskExecutionSummary>>;
-/** Load a fixed trailing window of completed executions stacked by task type. */
-export declare function readTaskExecutionDays(dayCount?: number, options?: {
-    nowMs?: number;
-}): Promise<TaskExecutionDay[]>;
-/** Load a fixed trailing window of completed executions stacked by hour. */
-export declare function readTaskExecutionHours(hourCount?: number, options?: {
-    nowMs?: number;
-}): Promise<TaskExecutionDay[]>;
-/** Load the newest terminal task execution linked to one conversation, if any. */
-export declare function readTaskExecutionByConversationId(args: {
-    conversationId: string;
-    namespace?: string;
-}): Promise<{
-    kind: TaskExecutionType;
-    taskId: string;
-} | undefined>;
-/** Load newest-first executions for one task, with conversation titles when present. */
-export declare function readTaskExecutions(args: {
-    kind: TaskExecutionType;
-    limit: number;
-    namespace?: string;
-    taskId: string;
-}): Promise<TaskExecutionRecord[]>;
-/** Load newest-first executions for the supplied viewer-visible tasks. */
-export declare function readTaskRuns(args: {
-    conversationIds?: string[];
-    limit: number;
-    namespace?: string;
-    tasks?: Array<{
-        kind: TaskExecutionType;
-        taskId: string;
-    }>;
-}): Promise<TaskRunRecord[]>;
-/** Load a fixed trailing window of terminal executions for one task by status. */
-export declare function readTaskExecutionStatusDays(args: {
-    dayCount?: number;
-    kind: TaskExecutionType;
-    namespace?: string;
-    nowMs?: number;
-    taskId: string;
-}): Promise<TaskExecutionStatusDay[]>;
-/** Load a fixed trailing window of terminal executions for one task by hour. */
-export declare function readTaskExecutionStatusHours(args: {
-    hourCount?: number;
-    kind: TaskExecutionType;
-    namespace?: string;
-    nowMs?: number;
-    taskId: string;
-}): Promise<TaskExecutionStatusDay[]>;

package/dist/chat/tasks/read.d.ts

@@ -1,22 +0,0 @@
-import type { User } from "@sentry/junior-plugin-api";
-import type { ConversationSourceTask } from "@/api/schema/conversation";
-import type { TaskExecutionList, TaskList, TaskRunList } from "@/api/schema/task";
-export declare function readViewerTasks(user: User): Promise<TaskList>;
-/**
- * Read newest runs across live viewer-visible tasks and deleted tasks the
- * viewer owns. Deleted task rows stay available so history does not depend on
- * conversation actor membership.
- */
-export declare function readViewerTaskRuns(user: User): Promise<TaskRunList>;
-export declare class ViewerTaskNotFoundError extends Error {
-    constructor();
-}
-/** Read one viewer-visible task and its newest terminal executions. */
-export declare function readViewerTaskExecutions(user: User, kind: "scheduled" | "event", id: string): Promise<TaskExecutionList>;
-/** Resolve the source task for one conversation when a terminal execution links it. */
-export declare function readConversationSourceTask(args: {
-    conversationId: string;
-    viewer?: User;
-}): Promise<ConversationSourceTask | undefined>;
-/** Delete one viewer-owned scheduled or event task. */
-export declare function deleteViewerTask(user: User, kind: "scheduled" | "event", id: string): Promise<void>;

package/dist/chat/tool-exposure.d.ts

@@ -1,10 +0,0 @@
-import type { AnyToolDefinition, ToolExposure } from "@/chat/tools/definition";
-export interface PlannedToolExposure {
-    catalogTools: Record<string, AnyToolDefinition>;
-    directTools: Record<string, AnyToolDefinition>;
-    excludedTools: Record<string, AnyToolDefinition>;
-}
-/** Return the runtime exposure for a tool, preserving direct compatibility. */
-export declare function effectiveToolExposure(definition: AnyToolDefinition): ToolExposure;
-/** Plan which tools are native-visible, catalog-executable, or withheld. */
-export declare function planToolExposure(tools: Record<string, AnyToolDefinition>): PlannedToolExposure;

package/dist/chat/tool-support/action-review-evidence.d.ts

@@ -1,4 +0,0 @@
-import type { PiMessage } from "@/chat/pi/messages";
-import type { ToolActionEvidence } from "@/chat/tool-support/action-review";
-/** Project the Codex Guardian transcript selection into structured evidence. */
-export declare function buildToolActionEvidence(messages: readonly PiMessage[]): ToolActionEvidence;

package/dist/chat/tool-support/action-review-history.d.ts

@@ -1,117 +0,0 @@
-import type { PiMessage } from "@/chat/pi/messages";
-import { z } from "zod";
-declare const priorRejectionSchema: z.ZodObject<{
-    decision: z.ZodEnum<{
-        ask: "ask";
-        deny: "deny";
-    }>;
-    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    reason: z.ZodString;
-    riskLevel: z.ZodOptional<z.ZodEnum<{
-        low: "low";
-        medium: "medium";
-        high: "high";
-        critical: "critical";
-    }>>;
-    tool: z.ZodObject<{
-        annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        description: z.ZodString;
-        dispatcherName: z.ZodOptional<z.ZodString>;
-        identity: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-            plugin: z.ZodString;
-        }, z.core.$strict>>;
-        name: z.ZodString;
-        proposalDescription: z.ZodOptional<z.ZodString>;
-        catalogSource: z.ZodOptional<z.ZodObject<{
-            description: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    userAuthorization: z.ZodOptional<z.ZodEnum<{
-        unknown: "unknown";
-        low: "low";
-        medium: "medium";
-        high: "high";
-    }>>;
-}, z.core.$strict>;
-export type ToolActionPriorRejection = z.output<typeof priorRejectionSchema>;
-declare const rejectionMarkerSchema: z.ZodObject<{
-    decision: z.ZodEnum<{
-        ask: "ask";
-        deny: "deny";
-    }>;
-    priorRejection: z.ZodObject<{
-        decision: z.ZodEnum<{
-            ask: "ask";
-            deny: "deny";
-        }>;
-        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        reason: z.ZodString;
-        riskLevel: z.ZodOptional<z.ZodEnum<{
-            low: "low";
-            medium: "medium";
-            high: "high";
-            critical: "critical";
-        }>>;
-        tool: z.ZodObject<{
-            annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            description: z.ZodString;
-            dispatcherName: z.ZodOptional<z.ZodString>;
-            identity: z.ZodOptional<z.ZodObject<{
-                id: z.ZodString;
-                name: z.ZodString;
-                plugin: z.ZodString;
-            }, z.core.$strict>>;
-            name: z.ZodString;
-            proposalDescription: z.ZodOptional<z.ZodString>;
-            catalogSource: z.ZodOptional<z.ZodObject<{
-                description: z.ZodString;
-                id: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        userAuthorization: z.ZodOptional<z.ZodEnum<{
-            unknown: "unknown";
-            low: "low";
-            medium: "medium";
-            high: "high";
-        }>>;
-    }, z.core.$strict>;
-    reason: z.ZodString;
-    riskLevel: z.ZodOptional<z.ZodEnum<{
-        low: "low";
-        medium: "medium";
-        high: "high";
-        critical: "critical";
-    }>>;
-    userAuthorization: z.ZodOptional<z.ZodEnum<{
-        unknown: "unknown";
-        low: "low";
-        medium: "medium";
-        high: "high";
-    }>>;
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>;
-/** Core-owned versioned transcript state for one rejected action. */
-export type ToolActionRejectionMarker = z.output<typeof rejectionMarkerSchema>;
-/** Read a core-owned action rejection marker from one durable Pi message. */
-export declare function getToolActionRejectionMarker(message: unknown): ToolActionRejectionMarker | undefined;
-/**
- * Consume and project one core-owned rejection into Pi's durable tool result.
- *
- * The marker field is reserved: tool-supplied values are stripped so only
- * state produced by the execution gate can survive into history.
- */
-export declare function projectToolActionRejection<TResult extends {
-    details?: unknown;
-    isError?: boolean;
-}>(pending: Map<string, ToolActionRejectionMarker>, toolCallId: string, result: TResult): TResult;
-/**
- * Restore compact Guardian rejection state from the durable Pi transcript.
- *
- * Tool results are not general Guardian evidence. Only core-generated action
- * rejection messages are recognized here and paired with their exact tool call.
- */
-export declare function restoreToolActionRejections(messages: readonly PiMessage[]): ToolActionPriorRejection[];
-export {};

package/dist/chat/tool-support/action-review.d.ts

@@ -1,143 +0,0 @@
-/**
- * Owns the execution gate for reviewable tool actions.
- *
- * Deterministic host checks establish authority before the model evaluates
- * untrusted action evidence.
- */
-import { type Destination, type Source, type ToolAnnotations } from "@sentry/junior-plugin-api";
-import type { Actor } from "@/chat/actor";
-import type { CredentialContext } from "@/chat/credentials/context";
-import type { AnyToolDefinition } from "@/chat/tools/definition";
-import type { ToolActionPriorRejection } from "@/chat/tool-support/action-review-history";
-/** Outcome available to the action reviewer. */
-export type ToolActionDecision = "allow" | "ask" | "deny";
-export interface ToolActionReviewDecision {
-    costUsd?: number;
-    decision: ToolActionDecision;
-    reason: string;
-    riskLevel: "low" | "medium" | "high" | "critical";
-    userAuthorization: "high" | "medium" | "low" | "unknown";
-}
-export interface ToolActionEvidence {
-    entries: Array<{
-        role: "assistant" | "user" | `tool ${string} call` | `tool ${string} result`;
-        text: string;
-    }>;
-    omittedEntries: number;
-}
-/** Exact model-review request; only core-supplied context carries authority. */
-export interface ToolActionProposal {
-    context: {
-        actor: {
-            platform: "local";
-            userId: string;
-        } | {
-            platform: "slack";
-            teamId: string;
-            userId: string;
-        } | {
-            platform: "system";
-            name: string;
-        };
-        conversationId: string;
-        credential?: {
-            actor: {
-                type: "user";
-                userId: string;
-            } | {
-                platform: "system";
-                name: string;
-            };
-            subject?: {
-                allowedWhen: "private-direct-conversation" | "scheduled-task" | "event-task";
-                taskId?: string;
-                type: "user";
-                userId: string;
-            };
-        };
-        destination: Destination;
-        source: Source;
-        userIntent: string;
-    };
-    evidence?: ToolActionEvidence;
-    input: Record<string, unknown>;
-    priorRejectedActions?: ToolActionPriorRejection[];
-    tool: {
-        annotations?: ToolAnnotations;
-        description: string;
-        dispatcherName?: string;
-        identity?: {
-            id: string;
-            name: string;
-            plugin: string;
-        };
-        name: string;
-        proposalDescription?: string;
-        catalogSource?: {
-            description: string;
-            id: string;
-        };
-    };
-}
-/** Guardian capability for one schema-constrained action proposal. */
-export interface ToolActionReviewer {
-    review(proposal: ToolActionProposal, options?: {
-        signal?: AbortSignal;
-    }): Promise<ToolActionReviewDecision>;
-}
-/** Core-owned context used to prepare one exact action for Guardian. */
-export interface ToolActionReviewContext {
-    actor?: Actor;
-    conversationId: string;
-    credentialContext?: CredentialContext;
-    destination: Destination;
-    source: Source;
-    userIntent?: () => string;
-    evidence?: () => ToolActionEvidence;
-}
-/** Review capability used immediately before tool execution. */
-export interface ToolActionReview {
-    review(toolCallId: string, toolName: string, tool: AnyToolDefinition, input: Record<string, unknown>, signal?: AbortSignal): Promise<ToolActionReviewDecision | undefined>;
-    projectToolResult<TResult extends {
-        details?: unknown;
-        isError?: boolean;
-    }>(toolCallId: string, result: TResult): TResult;
-}
-/** Expected tool failure when core or Guardian rejects an exact action. */
-export declare class ToolActionRejectedError extends Error {
-    readonly decision: Exclude<ToolActionDecision, "allow">;
-    readonly reason: string;
-    readonly reviewedAction?: ToolActionPriorRejection;
-    readonly riskLevel?: ToolActionReviewDecision["riskLevel"];
-    readonly userAuthorization?: ToolActionReviewDecision["userAuthorization"];
-    constructor(decision: Exclude<ToolActionDecision, "allow">, reason: string, assessment?: Partial<Pick<ToolActionReviewDecision, "riskLevel" | "userAuthorization">> & {
-        instructions?: string;
-        reviewedAction?: ToolActionPriorRejection;
-    });
-}
-/** Required review could not run, so the action was not executed. */
-export declare class ToolActionReviewUnavailableError extends Error {
-    constructor(options?: {
-        cause?: unknown;
-    });
-}
-/** Telemetry-only marker when action review exhausts consecutive rejections. */
-export declare class ToolActionReviewLimitError extends Error {
-    constructor();
-}
-/** Create the core review path that prepares actions and enforces Guardian decisions. */
-export declare function createToolActionReview(options: {
-    context: ToolActionReviewContext;
-    /** Persist the Guardian decision before the reviewed action can continue. */
-    onDecision(event: {
-        toolCallId: string;
-        toolName: string;
-        decision: ToolActionReviewDecision;
-    }): Promise<void>;
-    /** Escalate unavailable review to the owning agent-run boundary. */
-    onFatal(error: ToolActionReviewUnavailableError): void;
-    priorRejections?: ToolActionPriorRejection[];
-    reviewer: ToolActionReviewer;
-}): ToolActionReview;
-/** Review one exact tool action immediately before execution when required. */
-export declare function reviewToolAction(toolCallId: string, toolName: string, tool: AnyToolDefinition, input: Record<string, unknown>, review: ToolActionReview | undefined, signal?: AbortSignal): Promise<ToolActionReviewDecision | undefined>;

package/dist/chat/tool-support/catalog-tool-call.d.ts

@@ -1,10 +0,0 @@
-import { type AnyToolDefinition } from "@/chat/tools/definition";
-export interface CatalogToolCall {
-    arguments: Record<string, unknown>;
-    definition: AnyToolDefinition;
-    toolName: string;
-}
-/** Resolve and validate a catalog executeTool request at runtime. */
-export declare function resolveCatalogToolCall(input: Record<string, unknown>, catalogTools: Record<string, AnyToolDefinition>): CatalogToolCall;
-/** Apply a catalog tool's own argument preparation and schema boundary. */
-export declare function prepareCatalogToolCall(call: CatalogToolCall): CatalogToolCall;

package/dist/chat/tool-support/normalize-result.d.ts

@@ -1,9 +0,0 @@
-import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
-/** Normalize raw tool output into Pi content and structured details. */
-export declare function normalizeToolResult(result: unknown, options?: {
-    requireStructuredResult?: boolean;
-    toolName?: string;
-}): {
-    content: Array<TextContent | ImageContent>;
-    details: unknown;
-};

package/dist/chat/tool-support/pi-tool-adapter.d.ts

@@ -1,13 +0,0 @@
-import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { type ConversationPrivacy } from "@/chat/conversation-privacy";
-import { type LogContext } from "@/chat/logging";
-import type { PluginAuthOrchestration } from "@/chat/services/plugin-auth-orchestration";
-import type { AssistantStatusSpec } from "@/chat/slack/assistant-thread/status";
-import type { SandboxTools } from "@/chat/sandbox/sandbox";
-import type { SkillSandbox } from "@/chat/sandbox/skill-sandbox";
-import type { AnyToolDefinition } from "@/chat/tools/definition";
-import type { ToolExecutionReport } from "@/chat/tool-support/tool-execution-report";
-import type { PluginHookRunner } from "@/chat/plugins/agent-hooks";
-import { type ToolActionReview } from "@/chat/tool-support/action-review";
-/** Wrap tool definitions into Pi Agent tool objects with logging, validation, and sandbox execution. */
-export declare function createPiAgentTools(tools: Record<string, AnyToolDefinition>, sandbox: SkillSandbox, spanContext: LogContext, onStatus?: (status: AssistantStatusSpec) => void | Promise<void>, sandboxTools?: SandboxTools, pluginAuthOrchestration?: PluginAuthOrchestration, onToolCall?: (toolCallId: string, toolName: string, params: Record<string, unknown>) => void | Promise<void>, agentHooks?: PluginHookRunner, conversationPrivacy?: ConversationPrivacy, onToolResult?: (report: ToolExecutionReport) => void | Promise<void>, actionReview?: ToolActionReview): AgentTool[];

package/dist/chat/tool-support/private-trace-result.d.ts

@@ -1,4 +0,0 @@
-/** Mark one tool result as an adapter-approved private trace projection. */
-export declare function privateTraceResultAttributes(): Record<string, string>;
-/** Consume and remove the adapter-owned private trace projection marker. */
-export declare function consumePrivateTraceResultMarker(attributes: Record<string, unknown>): boolean;

package/dist/chat/tool-support/skill/mcp-tool-summary.d.ts

@@ -1,20 +0,0 @@
-import type { ManagedMcpToolDescriptor } from "@/chat/mcp/tool-manager";
-/** Agent-visible MCP tool descriptor with the provider schema as its argument contract. */
-export interface ExposedToolSummary {
-    tool_name: string;
-    mcp_tool_name: string;
-    provider: string;
-    title?: string;
-    description: string;
-    input_schema: Record<string, unknown>;
-    output_schema?: Record<string, unknown>;
-    annotations?: Record<string, unknown>;
-}
-export interface ActiveMcpCatalogSummary {
-    provider: string;
-    available_tool_count: number;
-}
-/** Convert a managed MCP tool descriptor into agent-visible search output. */
-export declare function toExposedToolSummary(toolDef: ManagedMcpToolDescriptor): ExposedToolSummary;
-/** Group discovered MCP tools into provider catalogs for prompt disclosure. */
-export declare function toActiveMcpCatalogSummaries(toolDefs: ManagedMcpToolDescriptor[]): ActiveMcpCatalogSummary[];

package/dist/chat/tool-support/structured-result.d.ts

@@ -1,44 +0,0 @@
-import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
-import { z } from "zod";
-export declare const juniorToolContinuationSchema: z.ZodObject<{
-    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export declare const juniorToolBoundContinuationSchema: z.ZodObject<{
-    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    reason: z.ZodOptional<z.ZodString>;
-    tool_name: z.ZodString;
-}, z.core.$strict>;
-/** Shared optional fields for canonical Junior tool outputs. */
-export declare const juniorToolOutputSchema: z.ZodObject<{
-    target: z.ZodOptional<z.ZodString>;
-    truncated: z.ZodOptional<z.ZodBoolean>;
-    timed_out: z.ZodOptional<z.ZodBoolean>;
-    continuation: z.ZodOptional<z.ZodObject<{
-        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$loose>;
-export type JuniorToolOutput = z.output<typeof juniorToolOutputSchema>;
-export interface JuniorToolOutputEnvelope<TDetails = unknown> {
-    content: [TextContent, ...(TextContent | ImageContent)[]];
-    details: TDetails;
-}
-/** Bind continuation metadata to the exposed runtime tool name. */
-export declare function injectContinuationToolName(details: unknown, toolName: string): unknown;
-export interface JuniorTextToolOutputEnvelope<TDetails = unknown> {
-    content: [TextContent];
-    details: TDetails;
-}
-/**
- * Project one canonical tool output onto Pi's native result channels.
- *
- * This follows the Codex tool-result model: `details` remains the authoritative
- * typed value, while `content` is its model-facing serialization. Telemetry and
- * execution success or failure are separate runtime projections and must not be
- * embedded in the tool output.
- */
-export declare function makeStructuredToolOutput<TDetails>(details: TDetails): JuniorTextToolOutputEnvelope<TDetails>;
-export declare function makeStructuredToolOutput<TDetails>(details: TDetails, options: {
-    content: Array<TextContent | ImageContent>;
-}): JuniorToolOutputEnvelope<TDetails>;

package/dist/chat/tool-support/text-range-result.d.ts

@@ -1,37 +0,0 @@
-interface TextRangeResult {
-    content: [{
-        type: "text";
-        text: string;
-    }];
-    details: {
-        target: string;
-        content: string;
-        end_line?: number;
-        path: string;
-        start_line: number;
-        total_lines: number;
-        truncation_reasons?: string[];
-        truncated: boolean;
-        character_limit_reached?: number;
-        line_truncated?: boolean;
-        continuation?: {
-            arguments: {
-                offset: number;
-                limit: number;
-                [key: string]: string | number;
-            };
-            reason: string;
-        };
-    };
-}
-/** Return a bounded line window so large files can be read incrementally. */
-export declare function sliceFileContent(params: {
-    content: string;
-    continuationArgumentName?: string;
-    limit?: unknown;
-    offset?: unknown;
-    path: string;
-}): TextRangeResult;
-/** Reject an expected missing read target through the tool-error channel. */
-export declare function missingFileResult(path: string): never;
-export {};

package/dist/chat/tool-support/timed-out-tool-result.d.ts

@@ -1,11 +0,0 @@
-import type { AfterToolCallResult, AgentToolResult } from "@earendil-works/pi-agent-core";
-/**
- * Project a host-preempted tool attempt onto the normal tool-result shape.
- *
- * Only rewrite results that mark the attempt itself as aborted. A finished
- * sibling tool that settles after the host abort signal must keep its real
- * outcome. Host continuity stays in session state (`resumeReason: "timeout"`)
- * and automatic continuation. The model only needs the same fact bash already
- * reports for command timeouts: this attempt timed out.
- */
-export declare function projectTimedOutToolResult(result: AgentToolResult<unknown>): AfterToolCallResult | undefined;

package/dist/chat/tool-support/tool-execution-report.d.ts

@@ -1,8 +0,0 @@
-export interface ToolExecutionReport {
-    error?: string;
-    ok: boolean;
-    params: Record<string, unknown>;
-    result?: unknown;
-    toolCallId: string;
-    toolName: string;
-}

package/dist/chat/tool-support/zod-tool.d.ts

@@ -1,46 +0,0 @@
-import { z, type ZodTypeAny } from "zod";
-import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
-import type { AnyToolDefinition, JsonSchemaObject, ToolExecuteOptions } from "@/chat/tools/definition";
-type ZodToolDefinitionBase<TInputSchema extends ZodTypeAny> = Pick<AnyToolDefinition, "approvalMode" | "identity" | "source" | "description" | "exposure" | "annotations" | "promptSnippet" | "promptGuidelines" | "executionMode"> & {
-    describeProposal?(input: z.output<TInputSchema>): string;
-    inputSchema: TInputSchema;
-    prepareArguments?: (args: unknown) => z.input<TInputSchema>;
-    resolveApprovalMetadata?(input: z.output<TInputSchema>): ReturnType<NonNullable<AnyToolDefinition["resolveApprovalMetadata"]>>;
-};
-type StructuredToolExecuteResult<TOutputSchema extends ZodTypeAny> = z.input<TOutputSchema> | StructuredToolResultEnvelope<z.input<TOutputSchema>>;
-interface StructuredToolResultEnvelope<TDetails> {
-    content: Array<TextContent | ImageContent>;
-    details: TDetails;
-}
-export interface ContentOnlyToolResult {
-    content: Array<TextContent | ImageContent>;
-    details?: never;
-}
-type StructuredZodToolDefinition<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodTypeAny, TExecuteResult extends StructuredToolExecuteResult<TOutputSchema>> = ZodToolDefinitionBase<TInputSchema> & {
-    outputSchema: TOutputSchema;
-    privateTraceResult?(result: z.output<TOutputSchema>): unknown;
-    execute?: (input: z.output<TInputSchema>, options: ToolExecuteOptions) => Promise<TExecuteResult> | TExecuteResult;
-};
-type ContentZodToolDefinition<TInputSchema extends ZodTypeAny> = ZodToolDefinitionBase<TInputSchema> & {
-    outputSchema?: undefined;
-    execute?: (input: z.output<TInputSchema>, options: ToolExecuteOptions) => Promise<ContentOnlyToolResult> | ContentOnlyToolResult;
-};
-type ParsedStructuredToolExecuteResult<TOutputSchema extends ZodTypeAny, TExecuteResult> = TExecuteResult extends StructuredToolResultEnvelope<unknown> ? StructuredToolResultEnvelope<z.output<TOutputSchema>> : z.output<TOutputSchema>;
-type StructuredZodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodTypeAny, TExecuteResult> = Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
-    inputSchema: JsonSchemaObject;
-    outputSchema: JsonSchemaObject;
-    prepareArguments(args: unknown): z.output<TInputSchema>;
-    execute?: (input: unknown, options: ToolExecuteOptions) => Promise<ParsedStructuredToolExecuteResult<TOutputSchema, TExecuteResult>> | ParsedStructuredToolExecuteResult<TOutputSchema, TExecuteResult>;
-};
-type ContentZodTool<TInputSchema extends ZodTypeAny> = Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
-    inputSchema: JsonSchemaObject;
-    outputSchema?: undefined;
-    prepareArguments(args: unknown): z.output<TInputSchema>;
-    execute?: (input: unknown, options: ToolExecuteOptions) => Promise<ContentOnlyToolResult> | ContentOnlyToolResult;
-};
-/**
- * Define a Junior-owned tool with Zod input parsing and JSON Schema parameters.
- */
-export declare function zodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodTypeAny, TExecuteResult extends StructuredToolExecuteResult<TOutputSchema>>(definition: StructuredZodToolDefinition<TInputSchema, TOutputSchema, TExecuteResult>): StructuredZodTool<TInputSchema, TOutputSchema, TExecuteResult>;
-export declare function zodTool<TInputSchema extends ZodTypeAny>(definition: ContentZodToolDefinition<TInputSchema>): ContentZodTool<TInputSchema>;
-export {};