@xfey/tutti 0.1.127 → 0.1.129

package/dist/approvals/decision-command.d.ts

@@ -25,8 +25,8 @@ export declare function executeApprovalDecisionCommand(input: {
         state: "pending";
         request: {
             expires_at?: string;
-            task_id?: string;
             activity_ref?: string;
+            task_id?: string;
             reason?: string;
             file_change?: {
                 paths?: string[];
@@ -69,8 +69,8 @@ export declare function executeApprovalDecisionCommand(input: {
         state: "resolved";
         request: {
             expires_at?: string;
-            task_id?: string;
             activity_ref?: string;
+            task_id?: string;
             reason?: string;
             file_change?: {
                 paths?: string[];

package/dist/chat-assistant/diagnostics.d.ts

@@ -1,21 +1,35 @@
 import type { ProviderInvocationProgress } from "../providers/invocation-progress.js";
 import type { languageDiagnosticFields } from "../communication-language/index.js";
+import type { ChatFailureCode } from "./failures.js";
+import type { WorkflowKind } from "@tutti/shared/domain";
+export type ChatInspectionBlocker = {
+    activity_ref: string;
+    activity_kind: "run" | "procedure";
+    workflow_kind?: WorkflowKind;
+};
 export type ChatAssistantLogger = {
     info: (fields: Record<string, unknown>, message: string) => void;
     warn: (fields: Record<string, unknown>, message: string) => void;
 };
 type ChatAssistantProgress = ProviderInvocationProgress | ({
     stage: "language_context";
-} & ReturnType<typeof languageDiagnosticFields>) | {
-    stage: "queued" | "inspection_wait" | "model_requested" | "reply_persisted" | "failed" | "skipped";
-    reason_code?: "queue_full" | "stopping" | "context_unavailable" | "answer_failed" | "reply_failed";
+} & ReturnType<typeof languageDiagnosticFields>) | ({
+    stage: "inspection_blocked";
+} & ChatInspectionBlocker) | {
+    stage: "queued" | "inspection_wait" | "model_requested" | "reply_persisted" | "notification_failed" | "failed" | "skipped";
+    reason_code?: "queue_full" | "stopping" | "context_unavailable" | "answer_failed" | "reply_failed" | "request_changed";
+    error_code?: ChatFailureCode;
+    diagnostic_id?: string;
     reference_source_count?: number;
+    queue_wait_ms?: number;
 };
 export declare function createChatAssistantDiagnostics(options: {
     logger?: ChatAssistantLogger;
     projectId: string;
     triggerMessageId: string;
     scope: string;
+    requestRef?: string;
+    attemptRef?: string;
 }): (event: ChatAssistantProgress) => void;
 export {};
 //# sourceMappingURL=diagnostics.d.ts.map

package/dist/chat-assistant/diagnostics.js

@@ -1,18 +1,21 @@
 import { createEventRef } from "@tutti/shared/ids";
 export function createChatAssistantDiagnostics(options) {
-    const requestRef = createEventRef();
+    const requestRef = options.requestRef ?? createEventRef();
     const started = performance.now();
     return (event) => {
         try {
             const fields = {
                 project_id: options.projectId,
                 chat_request_ref: requestRef,
+                ...(options.attemptRef === undefined ? {} : { attempt_ref: options.attemptRef }),
                 trigger_message_ref: options.triggerMessageId,
                 scope: options.scope,
                 elapsed_ms: Math.round(performance.now() - started),
                 ...event,
             };
-            if (event.stage === "failed" || event.stage === "provider_failed") {
+            if (event.stage === "failed" ||
+                event.stage === "provider_failed" ||
+                event.stage === "notification_failed") {
                 options.logger?.warn(fields, "Chat assistant progress");
             }
             else {

package/dist/chat-assistant/failure-messages.d.ts

@@ -0,0 +1,4 @@
+import type { NoticeLocale } from "../communication-language/notice-locale.js";
+import type { ChatFailureCode } from "./failures.js";
+export declare function chatFailureCopy(code: ChatFailureCode, locale: NoticeLocale): string;
+//# sourceMappingURL=failure-messages.d.ts.map

package/dist/chat-assistant/failure-messages.js

@@ -0,0 +1,57 @@
+const messages = {
+    en: {
+        reference_authorization_required: "Authorize document access using the group card, then send your question again. Authorization does not restart this answer.",
+        chat_queue_full: "Tutti is busy answering other questions. Try again shortly.",
+        chat_context_unavailable: "This question's conversation is no longer available.",
+        host_restarted: "The Host restarted before this answer was saved. Send your question again.",
+        provider_not_configured: "Ask the project owner to configure model access, then send your question again.",
+        provider_auth_invalid: "Model access could not be verified. Ask the project owner to check it.",
+        provider_quota_or_billing_required: "Model credit is unavailable. Ask the project owner to check the account.",
+        provider_rate_limited: "The model service is busy. Wait a moment, then send your question again.",
+        provider_network_error: "The model service could not be reached. Try again when the connection is available.",
+        provider_model_unavailable: "The selected model is unavailable. Ask the project owner to check model access.",
+        provider_timeout: "The model did not finish answering in time. You can send your question again.",
+        provider_output_invalid: "The model did not return a usable answer. You can send your question again.",
+        provider_lifecycle_failed: "The model process could not close safely. Restart the Host before trying again.",
+        chat_reply_persistence_failed: "The answer could not be saved. Check the Host diagnostics before trying again.",
+        internal_error: "Tutti could not complete this read-only answer. Share the diagnostic ID if this persists.",
+    },
+    "zh-Hans": {
+        reference_authorization_required: "请先通过群内卡片授权文档访问，然后重新提问。授权不会自动重启这次回答。",
+        chat_queue_full: "Tutti 正在回答其他问题，请稍后再试。",
+        chat_context_unavailable: "这条问题所在的对话已不可用。",
+        host_restarted: "本机运行时在回答保存前重启了，请重新发送问题。",
+        provider_not_configured: "请联系项目负责人配置模型接入，然后重新提问。",
+        provider_auth_invalid: "无法验证模型接入，请联系项目负责人检查配置。",
+        provider_quota_or_billing_required: "模型额度不可用，请联系项目负责人检查账号。",
+        provider_rate_limited: "模型服务繁忙，请稍后重新发送问题。",
+        provider_network_error: "无法连接模型服务，请在连接恢复后再试。",
+        provider_model_unavailable: "当前模型不可用，请联系项目负责人检查模型接入。",
+        provider_timeout: "这次回答超时了，你可以重新发送问题。",
+        provider_output_invalid: "模型没有返回可用的回答，你可以重新发送问题。",
+        provider_lifecycle_failed: "模型进程未能安全关闭，请重启本机运行时后再试。",
+        chat_reply_persistence_failed: "回答未能保存，请先检查本机运行时的诊断信息。",
+        internal_error: "Tutti 未能完成这次只读回答。如果问题持续，请提供诊断编号。",
+    },
+    "zh-Hant": {
+        reference_authorization_required: "請先透過群組卡片授權文件存取，然後重新提問。授權不會自動重新啟動這次回答。",
+        chat_queue_full: "Tutti 正在回答其他問題，請稍後再試。",
+        chat_context_unavailable: "這個問題所在的對話已無法使用。",
+        host_restarted: "本機執行環境在回答儲存前重新啟動了，請重新傳送問題。",
+        provider_not_configured: "請聯絡專案負責人設定模型連線，然後重新提問。",
+        provider_auth_invalid: "無法驗證模型連線，請聯絡專案負責人檢查設定。",
+        provider_quota_or_billing_required: "模型額度無法使用，請聯絡專案負責人檢查帳號。",
+        provider_rate_limited: "模型服務忙碌，請稍後重新傳送問題。",
+        provider_network_error: "無法連線至模型服務，請在連線恢復後再試。",
+        provider_model_unavailable: "目前的模型無法使用，請聯絡專案負責人檢查模型連線。",
+        provider_timeout: "這次回答逾時了，你可以重新傳送問題。",
+        provider_output_invalid: "模型沒有傳回可用的回答，你可以重新傳送問題。",
+        provider_lifecycle_failed: "模型程序未能安全關閉，請重新啟動本機執行環境後再試。",
+        chat_reply_persistence_failed: "回答未能儲存，請先檢查本機執行環境的診斷資訊。",
+        internal_error: "Tutti 未能完成這次唯讀回答。如果問題持續，請提供診斷編號。",
+    },
+};
+export function chatFailureCopy(code, locale) {
+    return messages[locale][code];
+}
+//# sourceMappingURL=failure-messages.js.map

package/dist/chat-assistant/failures.d.ts

@@ -0,0 +1,27 @@
+import type { OperationFailure } from "@tutti/shared/schemas/api";
+declare const failures: {
+    readonly reference_authorization_required: readonly ["access", "none"];
+    readonly chat_queue_full: readonly ["capacity", "resend_request"];
+    readonly chat_context_unavailable: readonly ["interrupted", "none"];
+    readonly host_restarted: readonly ["interrupted", "resend_request"];
+    readonly provider_not_configured: readonly ["configuration", "check_provider"];
+    readonly provider_auth_invalid: readonly ["access", "check_provider"];
+    readonly provider_quota_or_billing_required: readonly ["access", "check_provider"];
+    readonly provider_rate_limited: readonly ["capacity", "resend_request"];
+    readonly provider_network_error: readonly ["dependency", "resend_request"];
+    readonly provider_model_unavailable: readonly ["configuration", "check_provider"];
+    readonly provider_timeout: readonly ["dependency", "resend_request"];
+    readonly provider_output_invalid: readonly ["dependency", "resend_request"];
+    readonly provider_lifecycle_failed: readonly ["internal", "restart_host"];
+    readonly chat_reply_persistence_failed: readonly ["internal", "contact_support"];
+    readonly internal_error: readonly ["internal", "contact_support"];
+};
+export type ChatFailureCode = keyof typeof failures;
+type ChatFailure = OperationFailure & {
+    code: ChatFailureCode;
+};
+export declare function chatFailure(code: ChatFailureCode, diagnosticId?: string): ChatFailure;
+export declare function chatFailureMessage(failure: OperationFailure, locale?: string): string;
+export declare function classifyChatFailure(error: unknown, diagnosticId: string): ChatFailure;
+export {};
+//# sourceMappingURL=failures.d.ts.map

package/dist/chat-assistant/failures.js

@@ -0,0 +1,46 @@
+import { createEventRef } from "@tutti/shared/ids";
+import { providerFailureCode } from "../providers/failure-classification.js";
+import { noticeLocale } from "../communication-language/notice-locale.js";
+import { chatFailureCopy } from "./failure-messages.js";
+const failures = {
+    reference_authorization_required: ["access", "none"],
+    chat_queue_full: ["capacity", "resend_request"],
+    chat_context_unavailable: ["interrupted", "none"],
+    host_restarted: ["interrupted", "resend_request"],
+    provider_not_configured: ["configuration", "check_provider"],
+    provider_auth_invalid: ["access", "check_provider"],
+    provider_quota_or_billing_required: ["access", "check_provider"],
+    provider_rate_limited: ["capacity", "resend_request"],
+    provider_network_error: ["dependency", "resend_request"],
+    provider_model_unavailable: ["configuration", "check_provider"],
+    provider_timeout: ["dependency", "resend_request"],
+    provider_output_invalid: ["dependency", "resend_request"],
+    provider_lifecycle_failed: ["internal", "restart_host"],
+    chat_reply_persistence_failed: ["internal", "contact_support"],
+    internal_error: ["internal", "contact_support"],
+};
+export function chatFailure(code, diagnosticId = createEventRef()) {
+    const [category, recovery] = failures[code];
+    return { code, category, recovery, diagnostic_id: diagnosticId };
+}
+export function chatFailureMessage(failure, locale) {
+    const language = noticeLocale(locale);
+    const code = Object.hasOwn(failures, failure.code)
+        ? failure.code
+        : "internal_error";
+    const label = language === "zh-Hans" ? "诊断编号" : language === "zh-Hant" ? "診斷編號" : "Diagnostic ID";
+    return `${chatFailureCopy(code, language)} ${label}: ${failure.diagnostic_id}`;
+}
+// Allowlisted error facts only; neither error.message nor diagnostic callbacks
+// establish business truth. Unknown failures remain non-automatically-retryable.
+export function classifyChatFailure(error, diagnosticId) {
+    const value = typeof error === "object" && error !== null
+        ? error
+        : {};
+    const code = typeof value.code === "string" ? value.code : value.reason;
+    const mapped = typeof code === "string" && Object.hasOwn(failures, code)
+        ? code
+        : (providerFailureCode(error) ?? "internal_error");
+    return chatFailure(mapped, diagnosticId);
+}
+//# sourceMappingURL=failures.js.map

package/dist/chat-assistant/index.d.ts

@@ -1,6 +1,6 @@
-import type { ProjectId } from "@tutti/shared/ids";
+import { type ProjectId } from "@tutti/shared/ids";
 import type { MessageProjection } from "@tutti/shared/schemas/api";
-import { type ChatAssistantLogger } from "./diagnostics.js";
+import { type ChatAssistantLogger, type ChatInspectionBlocker } from "./diagnostics.js";
 import type { ProviderInvocationProgressObserver } from "../providers/invocation-progress.js";
 import { type HostProjectStore, type SqliteDatabase } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
@@ -33,6 +33,7 @@ export type ReadOnlyChatAssistantEnqueueResult = {
     triggered: boolean;
 };
 export type ReadOnlyChatAssistantHandle = {
+    register: (tx: SqliteDatabase, message: MessageProjection) => void;
     enqueue: (input: ReadOnlyChatAssistantTriggerInput) => ReadOnlyChatAssistantEnqueueResult;
     waitForIdle: () => Promise<void>;
     stopAccepting: () => void;
@@ -54,7 +55,8 @@ export type ReadOnlyChatAssistantOptions = {
         triggerMessage: MessageProjection;
         responseMessage: MessageProjection;
     }) => void | (() => void);
-    waitForInspectionAvailability?: () => Promise<void>;
+    waitForInspectionAvailability?: (onBlocked: (blocker: ChatInspectionBlocker) => void) => Promise<void>;
+    onRequestsChanged?: () => void;
     maxQueuedMentions?: number;
     now?: () => Date;
 };
@@ -62,16 +64,27 @@ export declare function isChatAssistantOutput(value: unknown): value is ChatAssi
 export declare function containsTuttiMention(value: string): boolean;
 export declare class ReadOnlyChatAssistant implements ReadOnlyChatAssistantHandle {
     private readonly options;
-    private readonly pending;
     private readonly idleWaiters;
     private active;
     private accepting;
     private readonly maxQueuedMentions;
+    private recoveryTimer;
+    private started;
+    private activeAttemptRef;
+    private storageFailureReported;
     constructor(options: ReadOnlyChatAssistantOptions);
+    /** Call once after Host recovery/transport wiring. No old messages are backfilled. */
+    start(): void;
+    register(tx: SqliteDatabase, message: MessageProjection): void;
+    private now;
+    private report;
     enqueue(input: ReadOnlyChatAssistantTriggerInput): ReadOnlyChatAssistantEnqueueResult;
     waitForIdle(): Promise<void>;
     stopAccepting(): void;
     private pump;
+    private reportStorageFailure;
+    private pumpNext;
+    private notifyRequestsChanged;
     private resolveIdleIfNeeded;
     private buildMainChatContext;
     private buildClarificationRoundContext;
@@ -80,6 +93,7 @@ export declare class ReadOnlyChatAssistant implements ReadOnlyChatAssistantHandl
     private appendMainChatAssistantMessage;
     private appendClarificationRoundAssistantMessage;
     private appendAssistantMessageForTrigger;
+    private recordReply;
     private respond;
 }
 //# sourceMappingURL=index.d.ts.map