@oyasmi/pipiclaw 0.5.1 → 0.5.3

package/dist/agent/session-events.js

@@ -0,0 +1,215 @@
+import * as log from "../log.js";
+import { extractLabelFromArgs, truncate } from "../shared/text-utils.js";
+import { isRecord } from "../shared/type-guards.js";
+import { extractToolResultText, formatProgressEntry } from "./progress-formatter.js";
+import { extractCustomCommandResultText, isAssistantEventMessage, isAutoCompactionEndEvent, isAutoCompactionStartEvent, isAutoRetryStartEvent, isMessageEndEvent, isMessageStartEvent, isSubAgentToolDetails, isTextPart, isThinkingPart, isToolExecutionEndEvent, isToolExecutionStartEvent, isToolExecutionUpdateEvent, isTurnEndEvent, } from "./type-guards.js";
+function mergeSubAgentUsage(totalUsage, details) {
+    totalUsage.input += details.usage.input;
+    totalUsage.output += details.usage.output;
+    totalUsage.cacheRead += details.usage.cacheRead;
+    totalUsage.cacheWrite += details.usage.cacheWrite;
+    totalUsage.total += details.usage.total;
+    totalUsage.cost.input += details.usage.cost.input;
+    totalUsage.cost.output += details.usage.cost.output;
+    totalUsage.cost.cacheRead += details.usage.cost.cacheRead;
+    totalUsage.cost.cacheWrite += details.usage.cost.cacheWrite;
+    totalUsage.cost.total += details.usage.cost.total;
+}
+function mergeAssistantUsage(runState, usage) {
+    runState.totalUsage.input += usage.input;
+    runState.totalUsage.output += usage.output;
+    runState.totalUsage.cacheRead += usage.cacheRead;
+    runState.totalUsage.cacheWrite += usage.cacheWrite;
+    runState.totalUsage.total +=
+        usage.total ?? usage.totalTokens ?? usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+    runState.totalUsage.cost.input += usage.cost.input;
+    runState.totalUsage.cost.output += usage.cost.output;
+    runState.totalUsage.cost.cacheRead += usage.cost.cacheRead;
+    runState.totalUsage.cost.cacheWrite += usage.cost.cacheWrite;
+    runState.totalUsage.cost.total += usage.cost.total;
+}
+export async function handleSessionEvent(event, context) {
+    const { ctx, logCtx, queue, pendingTools, store, runState, memoryLifecycle } = context;
+    if (isToolExecutionStartEvent(event)) {
+        const label = extractLabelFromArgs(event.args) || event.toolName;
+        pendingTools.set(event.toolCallId, {
+            toolName: event.toolName,
+            args: event.args,
+            startTime: Date.now(),
+        });
+        memoryLifecycle.noteToolCall();
+        log.logToolStart(logCtx, event.toolName, label, isRecord(event.args) ? event.args : {});
+        queue.enqueue(() => ctx.respond(formatProgressEntry("tool", label), false), "tool label");
+        return;
+    }
+    if (isToolExecutionUpdateEvent(event)) {
+        if (event.toolName !== "subagent") {
+            return;
+        }
+        const partialText = truncate(extractToolResultText(event.partialResult), 200);
+        if (!partialText.trim()) {
+            return;
+        }
+        queue.enqueue(() => ctx.respond(formatProgressEntry("tool", partialText), false), "tool update");
+        return;
+    }
+    if (isToolExecutionEndEvent(event)) {
+        const resultStr = extractToolResultText(event.result);
+        const pending = pendingTools.get(event.toolCallId);
+        pendingTools.delete(event.toolCallId);
+        const durationMs = pending ? Date.now() - pending.startTime : 0;
+        const subAgentDetails = event.toolName === "subagent" &&
+            isRecord(event.result) &&
+            "details" in event.result &&
+            isSubAgentToolDetails(event.result.details)
+            ? event.result.details
+            : null;
+        if (subAgentDetails) {
+            mergeSubAgentUsage(runState.totalUsage, subAgentDetails);
+            const label = pending?.args &&
+                typeof pending.args === "object" &&
+                "label" in pending.args &&
+                typeof pending.args.label === "string"
+                ? (pending.args.label ?? "subagent").trim()
+                : "subagent";
+            queue.enqueue(() => store?.logSubAgentRun(logCtx.channelId, {
+                date: new Date().toISOString(),
+                toolCallId: event.toolCallId,
+                label,
+                agent: subAgentDetails.agent,
+                source: subAgentDetails.source,
+                model: subAgentDetails.model,
+                tools: [...subAgentDetails.tools],
+                turns: subAgentDetails.turns,
+                toolCalls: subAgentDetails.toolCalls,
+                durationMs: subAgentDetails.durationMs,
+                failed: subAgentDetails.failed,
+                failureReason: subAgentDetails.failureReason,
+                output: resultStr.length > 16000 ? resultStr.slice(0, 16000) : resultStr,
+                outputTruncated: resultStr.length > 16000,
+                usage: {
+                    ...subAgentDetails.usage,
+                    cost: { ...subAgentDetails.usage.cost },
+                },
+            }) ?? Promise.resolve(), "sub-agent run log");
+        }
+        const treatAsError = event.isError || Boolean(subAgentDetails?.failed);
+        if (treatAsError) {
+            log.logToolError(logCtx, event.toolName, durationMs, resultStr);
+        }
+        else {
+            log.logToolSuccess(logCtx, event.toolName, durationMs, resultStr);
+        }
+        if (treatAsError) {
+            queue.enqueue(() => ctx.respond(formatProgressEntry("error", truncate(resultStr, 200)), false), "tool error");
+        }
+        return;
+    }
+    if (isMessageStartEvent(event)) {
+        if (isAssistantEventMessage(event.message)) {
+            log.logResponseStart(logCtx);
+        }
+        return;
+    }
+    if (isMessageEndEvent(event)) {
+        const commandResultText = extractCustomCommandResultText(event.message);
+        if (commandResultText) {
+            runState.finalOutcome = { kind: "final", text: commandResultText };
+            log.logResponse(logCtx, commandResultText);
+            queue.enqueue(async () => {
+                const delivered = await ctx.respondPlain(commandResultText);
+                if (!delivered) {
+                    await ctx.replaceMessage(commandResultText);
+                }
+                runState.finalResponseDelivered = true;
+            }, "command result");
+            return;
+        }
+        if (isAssistantEventMessage(event.message)) {
+            const assistantMsg = event.message;
+            if (assistantMsg.stopReason) {
+                runState.stopReason = assistantMsg.stopReason;
+            }
+            if (assistantMsg.errorMessage) {
+                runState.errorMessage = assistantMsg.errorMessage;
+            }
+            if (assistantMsg.usage) {
+                mergeAssistantUsage(runState, assistantMsg.usage);
+            }
+            const thinkingParts = [];
+            const textParts = [];
+            let hasToolCalls = false;
+            for (const part of assistantMsg.content) {
+                if (isThinkingPart(part)) {
+                    thinkingParts.push(part.thinking);
+                }
+                else if (isTextPart(part)) {
+                    textParts.push(part.text);
+                }
+                else if (part.type === "toolCall") {
+                    hasToolCalls = true;
+                }
+            }
+            const text = textParts.join("\n");
+            for (const thinking of thinkingParts) {
+                log.logThinking(logCtx, thinking);
+                queue.enqueue(() => ctx.respond(formatProgressEntry("thinking", thinking), false), "thinking");
+            }
+            if (hasToolCalls && text.trim()) {
+                queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", text), false), "assistant progress");
+            }
+        }
+        return;
+    }
+    if (isTurnEndEvent(event)) {
+        if (isAssistantEventMessage(event.message) && event.toolResults.length === 0) {
+            if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
+                return;
+            }
+            const finalText = event.message.content
+                .filter((part) => isTextPart(part))
+                .map((part) => part.text)
+                .join("\n");
+            const trimmedFinalText = finalText.trim();
+            if (!trimmedFinalText) {
+                return;
+            }
+            if (trimmedFinalText === "[SILENT]" || trimmedFinalText.startsWith("[SILENT]")) {
+                runState.finalOutcome = { kind: "silent" };
+                memoryLifecycle.noteCompletedAssistantTurn();
+                return;
+            }
+            if (runState.finalOutcome.kind === "final" && runState.finalOutcome.text.trim() === trimmedFinalText) {
+                return;
+            }
+            runState.finalOutcome = { kind: "final", text: finalText };
+            memoryLifecycle.noteCompletedAssistantTurn();
+            log.logResponse(logCtx, finalText);
+            queue.enqueue(async () => {
+                const delivered = await ctx.respondPlain(finalText);
+                if (delivered) {
+                    runState.finalResponseDelivered = true;
+                }
+            }, "final response");
+        }
+        return;
+    }
+    if (isAutoCompactionStartEvent(event)) {
+        log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
+        queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", "Compacting context..."), false), "compaction start");
+        return;
+    }
+    if (isAutoCompactionEndEvent(event)) {
+        if (event.result) {
+            log.logInfo(`Auto-compaction complete: ${event.result.tokensBefore} tokens compacted`);
+        }
+        else if (event.aborted) {
+            log.logInfo("Auto-compaction aborted");
+        }
+        return;
+    }
+    if (isAutoRetryStartEvent(event)) {
+        log.logWarning(`Retrying (${event.attempt}/${event.maxAttempts})`, event.errorMessage);
+        queue.enqueue(() => ctx.respond(formatProgressEntry("assistant", `Retrying (${event.attempt}/${event.maxAttempts})...`), false), "retry");
+    }
+}

package/dist/agent/session-resource-gate.d.ts

@@ -0,0 +1,10 @@
+export declare class SessionResourceGate {
+    private readonly reloadSessionResources;
+    private activePromptCount;
+    private refreshPending;
+    private reloadChain;
+    constructor(reloadSessionResources: () => Promise<void>);
+    runPrompt<T>(operation: () => Promise<T>): Promise<T>;
+    requestRefresh(): Promise<void>;
+    private flushPendingRefresh;
+}

package/dist/agent/session-resource-gate.js

@@ -0,0 +1,44 @@
+export class SessionResourceGate {
+    constructor(reloadSessionResources) {
+        this.reloadSessionResources = reloadSessionResources;
+        this.activePromptCount = 0;
+        this.refreshPending = false;
+        this.reloadChain = Promise.resolve();
+    }
+    async runPrompt(operation) {
+        await this.reloadChain;
+        this.activePromptCount++;
+        try {
+            return await operation();
+        }
+        finally {
+            this.activePromptCount--;
+            await this.flushPendingRefresh();
+        }
+    }
+    async requestRefresh() {
+        this.refreshPending = true;
+        if (this.activePromptCount > 0) {
+            return;
+        }
+        await this.flushPendingRefresh();
+    }
+    async flushPendingRefresh() {
+        if (!this.refreshPending || this.activePromptCount > 0) {
+            return;
+        }
+        this.refreshPending = false;
+        const runReload = async () => {
+            if (this.activePromptCount > 0) {
+                this.refreshPending = true;
+                return;
+            }
+            await this.reloadSessionResources();
+        };
+        this.reloadChain = this.reloadChain.then(runReload, runReload);
+        await this.reloadChain;
+        if (this.refreshPending && this.activePromptCount === 0) {
+            await this.flushPendingRefresh();
+        }
+    }
+}

package/dist/agent/type-guards.d.ts

@@ -0,0 +1,22 @@
+import type { SubAgentToolDetails } from "../subagents/tool.js";
+import type { AssistantContentPart, AssistantEventMessage, AssistantUsageMessage, AutoCompactionEndEvent, AutoCompactionStartEvent, AutoRetryStartEvent, MessageEndEvent, MessageStartEvent, ToolExecutionEndEvent, ToolExecutionStartEvent, ToolExecutionUpdateEvent, TurnEndEvent } from "./types.js";
+export declare function isAssistantEventMessage(value: unknown): value is AssistantEventMessage;
+export declare function isAssistantUsageMessage(value: unknown): value is AssistantUsageMessage;
+export declare function getLastAssistantUsage(messages: readonly unknown[]): AssistantUsageMessage | null;
+export declare function isThinkingPart(part: AssistantContentPart): part is Extract<AssistantContentPart, {
+    type: "thinking";
+}>;
+export declare function isTextPart(part: AssistantContentPart): part is Extract<AssistantContentPart, {
+    type: "text";
+}>;
+export declare function isToolExecutionStartEvent(value: unknown): value is ToolExecutionStartEvent;
+export declare function isToolExecutionUpdateEvent(value: unknown): value is ToolExecutionUpdateEvent;
+export declare function isToolExecutionEndEvent(value: unknown): value is ToolExecutionEndEvent;
+export declare function isMessageStartEvent(value: unknown): value is MessageStartEvent;
+export declare function isMessageEndEvent(value: unknown): value is MessageEndEvent;
+export declare function isTurnEndEvent(value: unknown): value is TurnEndEvent;
+export declare function isAutoCompactionStartEvent(value: unknown): value is AutoCompactionStartEvent;
+export declare function isAutoCompactionEndEvent(value: unknown): value is AutoCompactionEndEvent;
+export declare function isAutoRetryStartEvent(value: unknown): value is AutoRetryStartEvent;
+export declare function isSubAgentToolDetails(value: unknown): value is SubAgentToolDetails;
+export declare function extractCustomCommandResultText(message: unknown): string | null;

package/dist/agent/type-guards.js

@@ -0,0 +1,106 @@
+import { COMMAND_RESULT_CUSTOM_TYPE } from "../command-extension.js";
+import { isRecord } from "../shared/type-guards.js";
+function isMessageWithRole(value) {
+    return isRecord(value) && typeof value.role === "string";
+}
+export function isAssistantEventMessage(value) {
+    return (isMessageWithRole(value) && value.role === "assistant" && Array.isArray(value.content));
+}
+export function isAssistantUsageMessage(value) {
+    if (!isMessageWithRole(value) || value.role !== "assistant" || !("usage" in value) || !isRecord(value.usage)) {
+        return false;
+    }
+    return (typeof value.usage.input === "number" &&
+        typeof value.usage.output === "number" &&
+        typeof value.usage.cacheRead === "number" &&
+        typeof value.usage.cacheWrite === "number" &&
+        isRecord(value.usage.cost) &&
+        typeof value.usage.cost.input === "number" &&
+        typeof value.usage.cost.output === "number" &&
+        typeof value.usage.cost.cacheRead === "number" &&
+        typeof value.usage.cost.cacheWrite === "number" &&
+        typeof value.usage.cost.total === "number");
+}
+export function getLastAssistantUsage(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (isAssistantUsageMessage(message) && message.stopReason !== "aborted") {
+            return message;
+        }
+    }
+    return null;
+}
+export function isThinkingPart(part) {
+    return part.type === "thinking" && typeof part.thinking === "string";
+}
+export function isTextPart(part) {
+    return part.type === "text" && typeof part.text === "string";
+}
+function hasEventType(value, type) {
+    return isRecord(value) && value.type === type;
+}
+export function isToolExecutionStartEvent(value) {
+    return (hasEventType(value, "tool_execution_start") &&
+        typeof value.toolCallId === "string" &&
+        typeof value.toolName === "string");
+}
+export function isToolExecutionUpdateEvent(value) {
+    return (hasEventType(value, "tool_execution_update") &&
+        typeof value.toolCallId === "string" &&
+        typeof value.toolName === "string");
+}
+export function isToolExecutionEndEvent(value) {
+    return (hasEventType(value, "tool_execution_end") &&
+        typeof value.toolCallId === "string" &&
+        typeof value.toolName === "string" &&
+        typeof value.isError === "boolean");
+}
+export function isMessageStartEvent(value) {
+    return hasEventType(value, "message_start") && "message" in value;
+}
+export function isMessageEndEvent(value) {
+    return hasEventType(value, "message_end") && "message" in value;
+}
+export function isTurnEndEvent(value) {
+    return hasEventType(value, "turn_end") && "message" in value && Array.isArray(value.toolResults);
+}
+export function isAutoCompactionStartEvent(value) {
+    return hasEventType(value, "auto_compaction_start") && (value.reason === "threshold" || value.reason === "overflow");
+}
+export function isAutoCompactionEndEvent(value) {
+    return hasEventType(value, "auto_compaction_end");
+}
+export function isAutoRetryStartEvent(value) {
+    return (hasEventType(value, "auto_retry_start") &&
+        typeof value.attempt === "number" &&
+        typeof value.maxAttempts === "number" &&
+        typeof value.errorMessage === "string");
+}
+export function isSubAgentToolDetails(value) {
+    if (!value || typeof value !== "object" || !("kind" in value) || value.kind !== "subagent") {
+        return false;
+    }
+    if (!("usage" in value)) {
+        return false;
+    }
+    const usage = value.usage;
+    return (!!usage &&
+        typeof usage === "object" &&
+        "input" in usage &&
+        "output" in usage &&
+        "cacheRead" in usage &&
+        "cacheWrite" in usage &&
+        "cost" in usage);
+}
+export function extractCustomCommandResultText(message) {
+    if (!message ||
+        typeof message !== "object" ||
+        !("role" in message) ||
+        !("customType" in message) ||
+        message.role !== "custom" ||
+        message.customType !== COMMAND_RESULT_CUSTOM_TYPE) {
+        return null;
+    }
+    const content = message.content;
+    return typeof content === "string" && content.trim() ? content : null;
+}

package/dist/agent/types.d.ts

@@ -0,0 +1,160 @@
+import type { BuiltInCommand } from "../commands.js";
+import type { DingTalkContext } from "../runtime/dingtalk.js";
+import type { ChannelStore } from "../runtime/store.js";
+import type { UsageTotals } from "../shared/types.js";
+export interface AgentRunner {
+    run(ctx: DingTalkContext, store: ChannelStore): Promise<{
+        stopReason: string;
+        errorMessage?: string;
+    }>;
+    handleBuiltinCommand(ctx: DingTalkContext, command: BuiltInCommand): Promise<void>;
+    queueSteer(text: string, userName?: string): Promise<void>;
+    queueFollowUp(text: string, userName?: string): Promise<void>;
+    abort(): Promise<void>;
+}
+export type FinalOutcome = {
+    kind: "none";
+} | {
+    kind: "silent";
+} | {
+    kind: "final";
+    text: string;
+};
+export interface PendingTool {
+    toolName: string;
+    args: unknown;
+    startTime: number;
+}
+export interface RunQueue {
+    enqueue(fn: () => Promise<void>, errorContext: string): void;
+    enqueueMessage(text: string, target: "main" | "thread", errorContext: string, doLog?: boolean): void;
+}
+export interface RunLogContext {
+    channelId: string;
+    userName?: string;
+    channelName?: string;
+}
+export interface RunState {
+    ctx: DingTalkContext | null;
+    logCtx: RunLogContext | null;
+    store: ChannelStore | null;
+    queue: RunQueue | null;
+    pendingTools: Map<string, PendingTool>;
+    totalUsage: UsageTotals;
+    stopReason: string;
+    errorMessage: string | undefined;
+    finalOutcome: FinalOutcome;
+    finalResponseDelivered: boolean;
+}
+export declare function createEmptyRunState(): RunState;
+export interface AssistantUsage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total?: number;
+    totalTokens?: number;
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+}
+export type AssistantContentPart = {
+    type: "thinking";
+    thinking: string;
+} | {
+    type: "text";
+    text: string;
+} | {
+    type: "toolCall";
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export interface AssistantEventMessage {
+    role: "assistant";
+    content: AssistantContentPart[];
+    stopReason?: string;
+    errorMessage?: string;
+    usage?: AssistantUsage;
+}
+export interface AssistantUsageMessage {
+    role: "assistant";
+    stopReason?: string;
+    usage: AssistantUsage;
+}
+export type SessionEvent = {
+    type: "tool_execution_start";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+} | {
+    type: "tool_execution_update";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    partialResult: unknown;
+} | {
+    type: "tool_execution_end";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    isError: boolean;
+} | {
+    type: "message_start";
+    message: unknown;
+} | {
+    type: "message_end";
+    message: unknown;
+} | {
+    type: "turn_end";
+    message: unknown;
+    toolResults: unknown[];
+} | {
+    type: "auto_compaction_start";
+    reason: "threshold" | "overflow";
+} | {
+    type: "auto_compaction_end";
+    result?: {
+        tokensBefore: number;
+    };
+    aborted?: boolean;
+} | {
+    type: "auto_retry_start";
+    attempt: number;
+    maxAttempts: number;
+    delayMs?: number;
+    errorMessage: string;
+};
+export type ToolExecutionStartEvent = Extract<SessionEvent, {
+    type: "tool_execution_start";
+}>;
+export type ToolExecutionUpdateEvent = Extract<SessionEvent, {
+    type: "tool_execution_update";
+}>;
+export type ToolExecutionEndEvent = Extract<SessionEvent, {
+    type: "tool_execution_end";
+}>;
+export type MessageStartEvent = Extract<SessionEvent, {
+    type: "message_start";
+}>;
+export type MessageEndEvent = Extract<SessionEvent, {
+    type: "message_end";
+}>;
+export type TurnEndEvent = Extract<SessionEvent, {
+    type: "turn_end";
+}>;
+export type AutoCompactionStartEvent = Extract<SessionEvent, {
+    type: "auto_compaction_start";
+}>;
+export type AutoCompactionEndEvent = Extract<SessionEvent, {
+    type: "auto_compaction_end";
+}>;
+export type AutoRetryStartEvent = Extract<SessionEvent, {
+    type: "auto_retry_start";
+}>;
+export type ProgressEntryKind = "tool" | "thinking" | "error" | "assistant";
+export declare const MAX_USER_MESSAGE_CHARS = 12000;

package/dist/agent/types.js

@@ -0,0 +1,22 @@
+export function createEmptyRunState() {
+    return {
+        ctx: null,
+        logCtx: null,
+        store: null,
+        queue: null,
+        pendingTools: new Map(),
+        totalUsage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "stop",
+        errorMessage: undefined,
+        finalOutcome: { kind: "none" },
+        finalResponseDelivered: false,
+    };
+}
+export const MAX_USER_MESSAGE_CHARS = 12_000;

package/dist/agent.d.ts

@@ -1,16 +1,2 @@
-import { type BuiltInCommand } from "./commands.js";
-import type { DingTalkContext } from "./dingtalk.js";
-import { type SandboxConfig } from "./sandbox.js";
-import type { ChannelStore } from "./store.js";
-export interface AgentRunner {
-    run(ctx: DingTalkContext, store: ChannelStore): Promise<{
-        stopReason: string;
-        errorMessage?: string;
-    }>;
-    handleBuiltinCommand(ctx: DingTalkContext, command: BuiltInCommand): Promise<void>;
-    queueSteer(text: string, userName?: string): Promise<void>;
-    queueFollowUp(text: string, userName?: string): Promise<void>;
-    abort(): Promise<void>;
-}
-export declare function getOrCreateRunner(sandboxConfig: SandboxConfig, channelId: string, channelDir: string): AgentRunner;
-//# sourceMappingURL=agent.d.ts.map
+export type { AgentRunner } from "./agent/index.js";
+export { ChannelRunner, getOrCreateRunner } from "./agent/index.js";