psadk 1.3.7 → 1.4.3

package/build/main/lib/agent-core/types.d.ts

@@ -0,0 +1,385 @@
+import type { AssistantMessage, AssistantMessageEvent, ImageContent, Message, Model, SimpleStreamOptions, streamSimple, TextContent, Tool, ToolResultMessage } from '@earendil-works/pi-ai';
+import type { Static, TSchema } from 'typebox';
+/**
+ * Stream function used by the agent loop.
+ *
+ * Contract:
+ * - Must not throw or return a rejected promise for request/model/runtime failures.
+ * - Must return an AssistantMessageEventStream.
+ * - Failures must be encoded in the returned stream via protocol events and a
+ *   final AssistantMessage with stopReason "error" or "aborted" and errorMessage.
+ */
+export type StreamFn = (...args: Parameters<typeof streamSimple>) => ReturnType<typeof streamSimple> | Promise<ReturnType<typeof streamSimple>>;
+/**
+ * Configuration for how tool calls from a single assistant message are executed.
+ *
+ * - "sequential": each tool call is prepared, executed, and finalized before the next one starts.
+ * - "parallel": tool calls are prepared sequentially, then allowed tools execute concurrently.
+ *   `tool_execution_end` is emitted in tool completion order after each tool is finalized,
+ *   while tool-result message artifacts are emitted later in assistant source order.
+ */
+export type ToolExecutionMode = 'sequential' | 'parallel';
+/** A single tool call content block emitted by an assistant message. */
+export type AgentToolCall = Extract<AssistantMessage['content'][number], {
+    type: 'toolCall';
+}>;
+/**
+ * Result returned from `beforeToolCall`.
+ *
+ * Returning `{ block: true }` prevents the tool from executing. The loop emits an error tool result instead.
+ * `reason` becomes the text shown in that error result. If omitted, a default blocked message is used.
+ */
+export interface BeforeToolCallResult {
+    block?: boolean;
+    reason?: string;
+}
+/**
+ * Partial override returned from `afterToolCall`.
+ *
+ * Merge semantics are field-by-field:
+ * - `content`: if provided, replaces the tool result content array in full
+ * - `details`: if provided, replaces the tool result details value in full
+ * - `isError`: if provided, replaces the tool result error flag
+ * - `terminate`: if provided, replaces the early-termination hint
+ *
+ * Omitted fields keep the original executed tool result values.
+ * There is no deep merge for `content` or `details`.
+ */
+export interface AfterToolCallResult {
+    content?: (TextContent | ImageContent)[];
+    details?: unknown;
+    isError?: boolean;
+    /**
+     * Hint that the agent should stop after the current tool batch.
+     * Early termination only happens when every finalized tool result in the batch sets this to true.
+     */
+    terminate?: boolean;
+}
+/** Context passed to `beforeToolCall`. */
+export interface BeforeToolCallContext {
+    /** The assistant message that requested the tool call. */
+    assistantMessage: AssistantMessage;
+    /** The raw tool call block from `assistantMessage.content`. */
+    toolCall: AgentToolCall;
+    /** Validated tool arguments for the target tool schema. */
+    args: unknown;
+    /** Current agent context at the time the tool call is prepared. */
+    context: AgentContext;
+}
+/** Context passed to `afterToolCall`. */
+export interface AfterToolCallContext {
+    /** The assistant message that requested the tool call. */
+    assistantMessage: AssistantMessage;
+    /** The raw tool call block from `assistantMessage.content`. */
+    toolCall: AgentToolCall;
+    /** Validated tool arguments for the target tool schema. */
+    args: unknown;
+    /** The executed tool result before any `afterToolCall` overrides are applied. */
+    result: AgentToolResult<any>;
+    /** Whether the executed tool result is currently treated as an error. */
+    isError: boolean;
+    /** Current agent context at the time the tool call is finalized. */
+    context: AgentContext;
+}
+/** Context passed to `shouldStopAfterTurn`. */
+export interface ShouldStopAfterTurnContext {
+    /** The assistant message that completed the turn. */
+    message: AssistantMessage;
+    /** Tool result messages passed to the preceding `turn_end` event. */
+    toolResults: ToolResultMessage[];
+    /** Current agent context after the turn's assistant message and tool results have been appended. */
+    context: AgentContext;
+    /** Messages that this loop invocation will return if it exits at this point. Prompt runs include the initial prompt messages; continuation runs do not include pre-existing context messages. */
+    newMessages: AgentMessage[];
+}
+/** Replacement runtime state used by the agent loop before starting another provider request. */
+export interface AgentLoopTurnUpdate {
+    /** Context for the next provider request. */
+    context?: AgentContext;
+    /** Model for the next provider request. */
+    model?: Model<any>;
+    /** Thinking level for the next provider request. */
+    thinkingLevel?: ThinkingLevel;
+}
+export interface PrepareNextTurnContext extends ShouldStopAfterTurnContext {
+}
+export interface AgentLoopConfig extends SimpleStreamOptions {
+    model: Model<any>;
+    /**
+     * Converts AgentMessage[] to LLM-compatible Message[] before each LLM call.
+     *
+     * Each AgentMessage must be converted to a UserMessage, AssistantMessage, or ToolResultMessage
+     * that the LLM can understand. AgentMessages that cannot be converted (e.g., UI-only notifications,
+     * status messages) should be filtered out.
+     *
+     * Contract: must not throw or reject. Return a safe fallback value instead.
+     * Throwing interrupts the low-level agent loop without producing a normal event sequence.
+     *
+     * @example
+     * ```typescript
+     * convertToLlm: (messages) => messages.flatMap(m => {
+     *   if (m.role === "custom") {
+     *     // Convert custom message to user message
+     *     return [{ role: "user", content: m.content, timestamp: m.timestamp }];
+     *   }
+     *   if (m.role === "notification") {
+     *     // Filter out UI-only messages
+     *     return [];
+     *   }
+     *   // Pass through standard LLM messages
+     *   return [m];
+     * })
+     * ```
+     */
+    convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
+    /**
+     * Optional transform applied to the context before `convertToLlm`.
+     *
+     * Use this for operations that work at the AgentMessage level:
+     * - Context window management (pruning old messages)
+     * - Injecting context from external sources
+     *
+     * Contract: must not throw or reject. Return the original messages or another
+     * safe fallback value instead.
+     *
+     * @example
+     * ```typescript
+     * transformContext: async (messages) => {
+     *   if (estimateTokens(messages) > MAX_TOKENS) {
+     *     return pruneOldMessages(messages);
+     *   }
+     *   return messages;
+     * }
+     * ```
+     */
+    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
+    /**
+     * Resolves an API key dynamically for each LLM call.
+     *
+     * Useful for short-lived OAuth tokens (e.g., GitHub Copilot) that may expire
+     * during long-running tool execution phases.
+     *
+     * Contract: must not throw or reject. Return undefined when no key is available.
+     */
+    getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
+    /**
+     * Called after each turn fully completes and `turn_end` has been emitted.
+     *
+     * If it returns true, the loop emits `agent_end` and exits before polling steering or follow-up queues,
+     * without starting another LLM call. The current assistant response and any tool executions finish normally.
+     *
+     * Use this to request a graceful stop after the current turn, e.g. before context gets too full.
+     *
+     * Contract: must not throw or reject. Throwing interrupts the low-level agent loop without producing a normal event sequence.
+     */
+    shouldStopAfterTurn?: (context: ShouldStopAfterTurnContext) => boolean | Promise<boolean>;
+    /**
+     * Called after `turn_end` and before the loop decides whether another provider request should start.
+     * Return replacement context/model/thinking state to affect the next turn in this run.
+     * Return undefined to keep using the current context/config.
+     */
+    prepareNextTurn?: (context: PrepareNextTurnContext) => AgentLoopTurnUpdate | undefined | Promise<AgentLoopTurnUpdate | undefined>;
+    /**
+     * Returns steering messages to inject into the conversation mid-run.
+     *
+     * Called after the current assistant turn finishes executing its tool calls, unless `shouldStopAfterTurn` exits first.
+     * If messages are returned, they are added to the context before the next LLM call.
+     * Tool calls from the current assistant message are not skipped.
+     *
+     * Use this for "steering" the agent while it's working.
+     *
+     * Contract: must not throw or reject. Return [] when no steering messages are available.
+     */
+    getSteeringMessages?: () => Promise<AgentMessage[]>;
+    /**
+     * Returns follow-up messages to process after the agent would otherwise stop.
+     *
+     * Called when the agent has no more tool calls and no steering messages.
+     * If messages are returned, they're added to the context and the agent
+     * continues with another turn.
+     *
+     * Use this for follow-up messages that should wait until the agent finishes.
+     *
+     * Contract: must not throw or reject. Return [] when no follow-up messages are available.
+     */
+    getFollowUpMessages?: () => Promise<AgentMessage[]>;
+    /**
+     * Tool execution mode.
+     * - "sequential": execute tool calls one by one
+     * - "parallel": preflight tool calls sequentially, then execute allowed tools concurrently;
+     *   emit `tool_execution_end` in tool completion order after each tool is finalized,
+     *   then emit tool-result message artifacts later in assistant source order
+     *
+     * Default: "parallel"
+     */
+    toolExecution?: ToolExecutionMode;
+    /**
+     * Called before a tool is executed, after arguments have been validated.
+     *
+     * Return `{ block: true }` to prevent execution. The loop emits an error tool result instead.
+     * The hook receives the agent abort signal and is responsible for honoring it.
+     */
+    beforeToolCall?: (context: BeforeToolCallContext, signal?: AbortSignal) => Promise<BeforeToolCallResult | undefined>;
+    /**
+     * Called after a tool finishes executing, before `tool_execution_end` and tool-result message events are emitted.
+     *
+     * Return an `AfterToolCallResult` to override parts of the executed tool result:
+     * - `content` replaces the full content array
+     * - `details` replaces the full details payload
+     * - `isError` replaces the error flag
+     * - `terminate` replaces the early-termination hint
+     *
+     * Any omitted fields keep their original values. No deep merge is performed.
+     * The hook receives the agent abort signal and is responsible for honoring it.
+     */
+    afterToolCall?: (context: AfterToolCallContext, signal?: AbortSignal) => Promise<AfterToolCallResult | undefined>;
+}
+/**
+ * Thinking/reasoning level for models that support it.
+ * Note: "xhigh" is only supported by selected model families. Use model thinking-level metadata
+ * from @earendil-works/pi-ai to detect support for a concrete model.
+ */
+export type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+/**
+ * Extensible interface for custom app messages.
+ * Apps can extend via declaration merging:
+ *
+ * @example
+ * ```typescript
+ * declare module "@mariozechner/agent" {
+ *   interface CustomAgentMessages {
+ *     artifact: ArtifactMessage;
+ *     notification: NotificationMessage;
+ *   }
+ * }
+ * ```
+ */
+export interface CustomAgentMessages {
+}
+/**
+ * AgentMessage: Union of LLM messages + custom messages.
+ * This abstraction allows apps to add custom message types while maintaining
+ * type safety and compatibility with the base LLM messages.
+ */
+export type AgentMessage = Message | CustomAgentMessages[keyof CustomAgentMessages];
+/**
+ * Public agent state.
+ *
+ * `tools` and `messages` use accessor properties so implementations can copy
+ * assigned arrays before storing them.
+ */
+export interface AgentState {
+    /** System prompt sent with each model request. */
+    systemPrompt: string;
+    /** Active model used for future turns. */
+    model: Model<any>;
+    /** Requested reasoning level for future turns. */
+    thinkingLevel: ThinkingLevel;
+    /** Available tools. Assigning a new array copies the top-level array. */
+    set tools(tools: AgentTool<any>[]);
+    get tools(): AgentTool<any>[];
+    /** Conversation transcript. Assigning a new array copies the top-level array. */
+    set messages(messages: AgentMessage[]);
+    get messages(): AgentMessage[];
+    /**
+     * True while the agent is processing a prompt or continuation.
+     *
+     * This remains true until awaited `agent_end` listeners settle.
+     */
+    readonly isStreaming: boolean;
+    /** Partial assistant message for the current streamed response, if any. */
+    readonly streamingMessage?: AgentMessage;
+    /** Tool call ids currently executing. */
+    readonly pendingToolCalls: ReadonlySet<string>;
+    /** Error message from the most recent failed or aborted assistant turn, if any. */
+    readonly errorMessage?: string;
+}
+/** Final or partial result produced by a tool. */
+export interface AgentToolResult<T> {
+    /** Text or image content returned to the model. */
+    content: (TextContent | ImageContent)[];
+    /** Arbitrary structured details for logs or UI rendering. */
+    details: T;
+    /**
+     * Hint that the agent should stop after the current tool batch.
+     * Early termination only happens when every finalized tool result in the batch sets this to true.
+     */
+    terminate?: boolean;
+}
+/** Callback used by tools to stream partial execution updates. */
+export type AgentToolUpdateCallback<T = any> = (partialResult: AgentToolResult<T>) => void;
+/** Tool definition used by the agent runtime. */
+export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any> extends Tool<TParameters> {
+    /** Human-readable label for UI display. */
+    label: string;
+    /**
+     * Optional compatibility shim for raw tool-call arguments before schema validation.
+     * Must return an object that matches `TParameters`.
+     */
+    prepareArguments?: (args: unknown) => Static<TParameters>;
+    /** Execute the tool call. Throw on failure instead of encoding errors in `content`. */
+    execute: (toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails>) => Promise<AgentToolResult<TDetails>>;
+    /**
+     * Per-tool execution mode override.
+     * - "sequential": this tool must execute one at a time with other tool calls.
+     * - "parallel": this tool can execute concurrently with other tool calls.
+     *
+     * If omitted, the default execution mode applies.
+     */
+    executionMode?: ToolExecutionMode;
+}
+/** Context snapshot passed into the low-level agent loop. */
+export interface AgentContext {
+    /** System prompt included with the request. */
+    systemPrompt: string;
+    /** Transcript visible to the model. */
+    messages: AgentMessage[];
+    /** Tools available for this run. */
+    tools?: AgentTool<any>[];
+}
+/**
+ * Events emitted by the Agent for UI updates.
+ *
+ * `agent_end` is the last event emitted for a run, but awaited `Agent.subscribe()`
+ * listeners for that event are still part of run settlement. The agent becomes
+ * idle only after those listeners finish.
+ */
+export type AgentEvent = {
+    type: 'agent_start';
+} | {
+    type: 'agent_end';
+    messages: AgentMessage[];
+} | {
+    type: 'turn_start';
+} | {
+    type: 'turn_end';
+    message: AgentMessage;
+    toolResults: ToolResultMessage[];
+} | {
+    type: 'message_start';
+    message: AgentMessage;
+} | {
+    type: 'message_update';
+    message: AgentMessage;
+    assistantMessageEvent: AssistantMessageEvent;
+} | {
+    type: 'message_end';
+    message: AgentMessage;
+} | {
+    type: 'tool_execution_start';
+    toolCallId: string;
+    toolName: string;
+    args: any;
+} | {
+    type: 'tool_execution_update';
+    toolCallId: string;
+    toolName: string;
+    args: any;
+    partialResult: any;
+} | {
+    type: 'tool_execution_end';
+    toolCallId: string;
+    toolName: string;
+    result: any;
+    isError: boolean;
+};

package/build/main/lib/agent-core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2FnZW50LWNvcmUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/build/main/lib/skills/constants.js

@@ -16,10 +16,12 @@ const STATIC_CONSTANTS = {
     // Timing
     DEBOUNCE_DELAY: 500, // milliseconds
 };
-const SKILL_CONSTANTS = Object.assign(Object.assign({}, STATIC_CONSTANTS), { 
+const SKILL_CONSTANTS = {
+    ...STATIC_CONSTANTS,
     // Computed patterns using the constants
-    SKILL_WATCH_PATTERN: `${STATIC_CONSTANTS.SLINGSHOT_DIR}/${STATIC_CONSTANTS.SKILLS_DIR}/**/${STATIC_CONSTANTS.SKILL_DEFINITION_FILE}`, 
+    SKILL_WATCH_PATTERN: `${STATIC_CONSTANTS.SLINGSHOT_DIR}/${STATIC_CONSTANTS.SKILLS_DIR}/**/${STATIC_CONSTANTS.SKILL_DEFINITION_FILE}`,
     // Watch pattern for folder deletions - watch the entire skills directory
-    SKILLS_FOLDER_WATCH_PATTERN: `${STATIC_CONSTANTS.SLINGSHOT_DIR}/${STATIC_CONSTANTS.SKILLS_DIR}/**` });
+    SKILLS_FOLDER_WATCH_PATTERN: `${STATIC_CONSTANTS.SLINGSHOT_DIR}/${STATIC_CONSTANTS.SKILLS_DIR}/**`,
+};
 exports.default = SKILL_CONSTANTS;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9za2lsbHMvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUE7O0dBRUc7QUFDSCxNQUFNLGdCQUFnQixHQUFHO0lBQ3ZCLGtCQUFrQjtJQUNsQixhQUFhLEVBQUUsWUFBWTtJQUMzQixVQUFVLEVBQUUsU0FBUyxFQUFFLG9DQUFvQztJQUMzRCxVQUFVLEVBQUUsUUFBUTtJQUNwQixpQkFBaUIsRUFBRSxRQUFRLEVBQUUsNEJBQTRCO0lBRXpELGFBQWE7SUFDYixxQkFBcUIsRUFBRSxVQUFVO0lBQ2pDLGFBQWEsRUFBRSxxQkFBcUI7SUFDcEMsVUFBVSxFQUFFLG1CQUFtQjtJQUUvQixTQUFTO0lBQ1QsY0FBYyxFQUFFLEdBQUcsRUFBRSxlQUFlO0NBQ3JDLENBQUM7QUFFRixNQUFNLGVBQWUsbUNBQ2hCLGdCQUFnQjtJQUNuQix3Q0FBd0M7SUFDeEMsbUJBQW1CLEVBQUUsR0FBRyxnQkFBZ0IsQ0FBQyxhQUFhLElBQUksZ0JBQWdCLENBQUMsVUFBVSxPQUFPLGdCQUFnQixDQUFDLHFCQUFxQixFQUFFO0lBQ3BJLHlFQUF5RTtJQUN6RSwyQkFBMkIsRUFBRSxHQUFHLGdCQUFnQixDQUFDLGFBQWEsSUFBSSxnQkFBZ0IsQ0FBQyxVQUFVLEtBQUssR0FDbkcsQ0FBQztBQUVGLGtCQUFlLGVBQWUsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9za2lsbHMvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUE7O0dBRUc7QUFDSCxNQUFNLGdCQUFnQixHQUFHO0lBQ3ZCLGtCQUFrQjtJQUNsQixhQUFhLEVBQUUsWUFBWTtJQUMzQixVQUFVLEVBQUUsU0FBUyxFQUFFLG9DQUFvQztJQUMzRCxVQUFVLEVBQUUsUUFBUTtJQUNwQixpQkFBaUIsRUFBRSxRQUFRLEVBQUUsNEJBQTRCO0lBRXpELGFBQWE7SUFDYixxQkFBcUIsRUFBRSxVQUFVO0lBQ2pDLGFBQWEsRUFBRSxxQkFBcUI7SUFDcEMsVUFBVSxFQUFFLG1CQUFtQjtJQUUvQixTQUFTO0lBQ1QsY0FBYyxFQUFFLEdBQUcsRUFBRSxlQUFlO0NBQ3JDLENBQUM7QUFFRixNQUFNLGVBQWUsR0FBRztJQUN0QixHQUFHLGdCQUFnQjtJQUNuQix3Q0FBd0M7SUFDeEMsbUJBQW1CLEVBQUUsR0FBRyxnQkFBZ0IsQ0FBQyxhQUFhLElBQUksZ0JBQWdCLENBQUMsVUFBVSxPQUFPLGdCQUFnQixDQUFDLHFCQUFxQixFQUFFO0lBQ3BJLHlFQUF5RTtJQUN6RSwyQkFBMkIsRUFBRSxHQUFHLGdCQUFnQixDQUFDLGFBQWEsSUFBSSxnQkFBZ0IsQ0FBQyxVQUFVLEtBQUs7Q0FDbkcsQ0FBQztBQUVGLGtCQUFlLGVBQWUsQ0FBQyJ9

package/build/main/lib/skills/skillParser.js

@@ -43,8 +43,8 @@ function parseSkillMetadata(filePath) {
             folderPath: fullMetadata.path,
         };
     }
-    catch (_a) {
+    catch {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2tpbGxQYXJzZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NraWxscy9za2lsbFBhcnNlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQVVBLHNFQWNDO0FBT0QscUNBdUJDO0FBdERELHNEQUF5QjtBQUN6QiwwREFBNkI7QUFFN0IsOERBQWlDO0FBSWpDOztHQUVHO0FBQ0gsU0FBZ0IsNkJBQTZCLENBQzNDLE9BQWUsRUFDZixTQUFpQjtJQUVqQixNQUFNLE1BQU0sR0FBRyxJQUFBLHFCQUFNLEVBQUMsT0FBTyxDQUFDLENBQUM7SUFFL0IsT0FBTztRQUNMLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxTQUFTO1FBQ25DLFdBQVcsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQVcsSUFBSSwwQkFBMEI7UUFDbEUsT0FBTyxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTztRQUM1QixNQUFNLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNO1FBQzFCLE9BQU8sRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU87UUFDNUIsSUFBSSxFQUFFLFNBQVM7S0FDaEIsQ0FBQztBQUNKLENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBd0Isa0JBQWtCLENBQ3hDLFFBQWdCO0lBRWhCLElBQUksQ0FBQztRQUNILElBQUksQ0FBQyxpQkFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQzdCLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUVELE1BQU0sV0FBVyxHQUFHLGlCQUFFLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUN0RCxNQUFNLFNBQVMsR0FBRyxtQkFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUV6QyxtQ0FBbUM7UUFDbkMsTUFBTSxZQUFZLEdBQUcsNkJBQTZCLENBQUMsV0FBVyxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBRTNFLGtEQUFrRDtRQUNsRCxPQUFPO1lBQ0wsSUFBSSxFQUFFLFlBQVksQ0FBQyxJQUFJO1lBQ3ZCLFdBQVcsRUFBRSxZQUFZLENBQUMsV0FBVztZQUNyQyxVQUFVLEVBQUUsWUFBWSxDQUFDLElBQUk7U0FDOUIsQ0FBQztJQUNKLENBQUM7SUFBQyxXQUFNLENBQUM7UUFDUCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7QUFDSCxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2tpbGxQYXJzZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NraWxscy9za2lsbFBhcnNlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQVVBLHNFQWNDO0FBT0QscUNBdUJDO0FBdERELHNEQUF5QjtBQUN6QiwwREFBNkI7QUFFN0IsOERBQWlDO0FBSWpDOztHQUVHO0FBQ0gsU0FBZ0IsNkJBQTZCLENBQzNDLE9BQWUsRUFDZixTQUFpQjtJQUVqQixNQUFNLE1BQU0sR0FBRyxJQUFBLHFCQUFNLEVBQUMsT0FBTyxDQUFDLENBQUM7SUFFL0IsT0FBTztRQUNMLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxTQUFTO1FBQ25DLFdBQVcsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLFdBQVcsSUFBSSwwQkFBMEI7UUFDbEUsT0FBTyxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTztRQUM1QixNQUFNLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNO1FBQzFCLE9BQU8sRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU87UUFDNUIsSUFBSSxFQUFFLFNBQVM7S0FDaEIsQ0FBQztBQUNKLENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBd0Isa0JBQWtCLENBQ3hDLFFBQWdCO0lBRWhCLElBQUksQ0FBQztRQUNILElBQUksQ0FBQyxpQkFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQzdCLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUVELE1BQU0sV0FBVyxHQUFHLGlCQUFFLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUN0RCxNQUFNLFNBQVMsR0FBRyxtQkFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUV6QyxtQ0FBbUM7UUFDbkMsTUFBTSxZQUFZLEdBQUcsNkJBQTZCLENBQUMsV0FBVyxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBRTNFLGtEQUFrRDtRQUNsRCxPQUFPO1lBQ0wsSUFBSSxFQUFFLFlBQVksQ0FBQyxJQUFJO1lBQ3ZCLFdBQVcsRUFBRSxZQUFZLENBQUMsV0FBVztZQUNyQyxVQUFVLEVBQUUsWUFBWSxDQUFDLElBQUk7U0FDOUIsQ0FBQztJQUNKLENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7QUFDSCxDQUFDIn0=

package/build/main/lib/skills/utils.js

@@ -158,7 +158,7 @@ async function scanInstalledSkills(skillsPath) {
     try {
         await fs_1.promises.access(skillsPath);
     }
-    catch (_a) {
+    catch {
         return installedSkills;
     }
     try {
@@ -168,7 +168,7 @@ async function scanInstalledSkills(skillsPath) {
         try {
             await fs_1.promises.access(skillsDir);
         }
-        catch (_b) {
+        catch {
             dlog.info(`Skills directory does not exist: ${skillsDir}`);
             return installedSkills;
         }
@@ -206,7 +206,7 @@ async function loadSkillMetadata(skillDir) {
         const fileContent = await fs_1.promises.readFile(skillMdPath, 'utf-8');
         return (0, skillParser_1.parseSkillMetadataFromContent)(fileContent, skillDir);
     }
-    catch (_a) {
+    catch {
         return null;
     }
 }
@@ -349,14 +349,12 @@ async function getSkillsSystemPromptFromDirectory(skillsPath) {
  * Accepts skill sources as an object mapping skill names to source configurations
  */
 async function setupSkillsAndGetPrompt(skillsPath, sources, log) {
-    var _a;
     await ensureSkillsDirectory(skillsPath);
     if (sources) {
         const skillEntries = Object.entries(sources);
         if (skillEntries.length > 0) {
-            (_a = log === null || log === void 0 ? void 0 : log.info) === null || _a === void 0 ? void 0 : _a.call(log, `🚀 Installing ${skillEntries.length} skills from configuration...`);
+            log?.info?.(`🚀 Installing ${skillEntries.length} skills from configuration...`);
             await Promise.all(skillEntries.map(async ([skillName, config]) => {
-                var _a, _b, _c;
                 try {
                     // Validate the source
                     if (!config.source || !validateSkillSource(config.source)) {
@@ -369,16 +367,16 @@ async function setupSkillsAndGetPrompt(skillsPath, sources, log) {
                     if (!normalizedSource.includes('@')) {
                         sourceWithSkill = `${normalizedSource}@${skillName}`;
                     }
-                    (_a = log === null || log === void 0 ? void 0 : log.info) === null || _a === void 0 ? void 0 : _a.call(log, `⬇️ Installing skill "${skillName}" from ${config.source} (${config.sourceType || 'git'})`);
+                    log?.info?.(`⬇️ Installing skill "${skillName}" from ${config.source} (${config.sourceType || 'git'})`);
                     await installSkill({
                         source: sourceWithSkill,
                         skillsPath,
                         timeout: 60000,
                     });
-                    (_b = log === null || log === void 0 ? void 0 : log.info) === null || _b === void 0 ? void 0 : _b.call(log, `✅ Successfully installed skill: ${skillName}`);
+                    log?.info?.(`✅ Successfully installed skill: ${skillName}`);
                 }
                 catch (error) {
-                    (_c = log === null || log === void 0 ? void 0 : log.error) === null || _c === void 0 ? void 0 : _c.call(log, `❌ Failed to install skill "${skillName}":`, error);
+                    log?.error?.(`❌ Failed to install skill "${skillName}":`, error);
                     // Continue with other skills even if one fails
                 }
             }));
@@ -386,4 +384,4 @@ async function setupSkillsAndGetPrompt(skillsPath, sources, log) {
     }
     return await getSkillsSystemPromptFromDirectory(skillsPath);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/skills/utils.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/skills/utils.ts"],"names":[],"mappings":"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"}

package/build/main/lib/tools/BraveWebSearchTool.js

@@ -5,6 +5,8 @@ exports.BraveWebSearchTool = void 0;
 const v4_1 = require("zod/v4");
 const PSAgentTool_1 = require("../PSAgentTool");
 class BraveWebSearchTool extends PSAgentTool_1.PSAgentTool {
+    static toolName = 'search_web_with_brave';
+    braveSearchApiKey;
     constructor(options) {
         super({
             name: BraveWebSearchTool.toolName,
@@ -68,7 +70,7 @@ class BraveWebSearchTool extends PSAgentTool_1.PSAgentTool {
         }
         return new Promise((resolve, reject) => {
             try {
-                log === null || log === void 0 ? void 0 : log.info(`\n\n> Searching web: ${input.query}:\n`);
+                log?.info(`\n\n> Searching web: ${input.query}:\n`);
                 const output = this.bravewebsearch(input.query);
                 return resolve({
                     status: 'success',
@@ -87,5 +89,4 @@ class BraveWebSearchTool extends PSAgentTool_1.PSAgentTool {
     }
 }
 exports.BraveWebSearchTool = BraveWebSearchTool;
-BraveWebSearchTool.toolName = 'search_web_with_brave';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/tools/PSArtifactTool.js

@@ -4,6 +4,8 @@ exports.PSArtifactTool = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const PSAgentTool_1 = require("../PSAgentTool");
 class PSArtifactTool extends PSAgentTool_1.PSAgentTool {
+    static TOOL_NAME = 'artifact_tool';
+    artifacts = {};
     constructor(artifactsStore) {
         super({
             name: PSArtifactTool.TOOL_NAME,
@@ -42,7 +44,6 @@ The output will be a JSON object with the status and output result of the action
                 },
             },
         });
-        this.artifacts = {};
         if (artifactsStore) {
             this.artifacts = artifactsStore;
         }
@@ -75,5 +76,4 @@ The output will be a JSON object with the status and output result of the action
     }
 }
 exports.PSArtifactTool = PSArtifactTool;
-PSArtifactTool.TOOL_NAME = 'artifact_tool';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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