@sellable/mcp 0.1.315 → 0.1.319

package/dist/tools/bootstrap.js

@@ -18,7 +18,7 @@ function toGuidance(check, message) {
         return "Fix framework files and rerun bootstrap_create_campaign.";
     }
     if (check === "model_quality") {
-        return `Use at least ${getCampaignModelMinimumSummary()} for campaign-critical generation.`;
+        return `Use trusted active-turn metadata before enforcing the campaign model floor: ${getCampaignModelMinimumSummary()}.`;
     }
     if (check === "resume_context") {
         return "Confirm the campaignId exists and is accessible, then retry bootstrap_create_campaign.";
@@ -98,15 +98,19 @@ export const bootstrapToolDefinitions = [
                 },
                 host: {
                     type: "string",
-                    description: "Optional host label for model-quality preflight, for example Claude Code or Codex.",
+                    description: "Optional host label for active model-quality preflight, for example Claude Code or Codex.",
                 },
                 model: {
                     type: "string",
-                    description: `Optional current host model name. Minimum campaign quality config: ${getCampaignModelMinimumSummary()}.`,
+                    description: "Optional active host model name from runtime metadata. Do not pass config defaults.",
                 },
                 reasoningEffort: {
                     type: "string",
-                    description: `Optional current reasoning setting. Minimum campaign quality config: ${getCampaignModelMinimumSummary()}.`,
+                    description: "Optional active reasoning setting from runtime metadata. Do not pass config defaults.",
+                },
+                modelMetadataSource: {
+                    type: "string",
+                    description: "Where active model metadata came from, for example codex_turn_metadata, claude_runtime_metadata, claude_session_context, active_turn_metadata, or user_confirmed.",
                 },
             },
             additionalProperties: false,
@@ -129,6 +133,7 @@ export async function bootstrapCreateCampaign(input = {}) {
         host: input.host,
         model: input.model,
         reasoningEffort: input.reasoningEffort,
+        metadataSource: input.modelMetadataSource,
     });
     const runAuthCheck = async () => {
         let status = await getAuthStatus();
@@ -188,7 +193,7 @@ export async function bootstrapCreateCampaign(input = {}) {
     }
     requiredChecks.push({
         key: "model_quality",
-        ok: modelQuality.status === "ok",
+        ok: modelQuality.status !== "warn",
         blocking: false,
         detail: modelQuality.message,
     });

package/dist/tools/inbox.d.ts

@@ -0,0 +1,308 @@
+type ToolTextContent = {
+    type: "text";
+    text: string;
+};
+type ToolResult<T extends Record<string, unknown>> = {
+    structuredContent: T;
+    content: [ToolTextContent];
+    isError?: boolean;
+};
+export declare const inboxToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
+            cursor: {
+                type: string;
+            };
+            filter: {
+                type: string;
+                enum: string[];
+            };
+            status: {
+                type: string;
+                enum: string[];
+            };
+            senderId: {
+                type: string;
+            };
+            classification: {
+                type: string;
+            };
+            search: {
+                type: string;
+            };
+            includeEnrichment: {
+                type: string;
+            };
+            includeReplyEligibility: {
+                type: string;
+            };
+            threadId?: undefined;
+            versionId?: undefined;
+            body?: undefined;
+            approvedBody?: undefined;
+            approvedBodyHash?: undefined;
+            approvedThreadSnapshot?: undefined;
+            idempotencyKey?: undefined;
+            approval?: undefined;
+            message?: undefined;
+            approvedMessageHash?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: string;
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            threadId: {
+                type: string;
+            };
+            limit?: undefined;
+            cursor?: undefined;
+            filter?: undefined;
+            status?: undefined;
+            senderId?: undefined;
+            classification?: undefined;
+            search?: undefined;
+            includeEnrichment?: undefined;
+            includeReplyEligibility?: undefined;
+            versionId?: undefined;
+            body?: undefined;
+            approvedBody?: undefined;
+            approvedBodyHash?: undefined;
+            approvedThreadSnapshot?: undefined;
+            idempotencyKey?: undefined;
+            approval?: undefined;
+            message?: undefined;
+            approvedMessageHash?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: string;
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            threadId: {
+                type: string;
+            };
+            versionId: {
+                type: string;
+            };
+            body: {
+                type: string;
+            };
+            limit?: undefined;
+            cursor?: undefined;
+            filter?: undefined;
+            status?: undefined;
+            senderId?: undefined;
+            classification?: undefined;
+            search?: undefined;
+            includeEnrichment?: undefined;
+            includeReplyEligibility?: undefined;
+            approvedBody?: undefined;
+            approvedBodyHash?: undefined;
+            approvedThreadSnapshot?: undefined;
+            idempotencyKey?: undefined;
+            approval?: undefined;
+            message?: undefined;
+            approvedMessageHash?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: string;
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            threadId: {
+                type: string;
+            };
+            versionId: {
+                type: string;
+            };
+            approvedBody: {
+                type: string;
+            };
+            approvedBodyHash: {
+                type: string;
+            };
+            approvedThreadSnapshot: {
+                type: string;
+                properties: {
+                    latestMessageTimestamp: {
+                        type: string[];
+                    };
+                    lastInboundMessageAt: {
+                        type: string[];
+                    };
+                    updatedAt: {
+                        type: string[];
+                    };
+                    reasonCodes: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            idempotencyKey: {
+                type: string;
+            };
+            approval: {
+                type: string;
+                enum: string[];
+            };
+            limit?: undefined;
+            cursor?: undefined;
+            filter?: undefined;
+            status?: undefined;
+            senderId?: undefined;
+            classification?: undefined;
+            search?: undefined;
+            includeEnrichment?: undefined;
+            includeReplyEligibility?: undefined;
+            body?: undefined;
+            message?: undefined;
+            approvedMessageHash?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: string;
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            threadId: {
+                type: string;
+            };
+            message: {
+                type: string;
+            };
+            approvedMessageHash: {
+                type: string;
+            };
+            approvedThreadSnapshot: {
+                type: string;
+                properties: {
+                    latestMessageTimestamp: {
+                        type: string[];
+                    };
+                    lastInboundMessageAt: {
+                        type: string[];
+                    };
+                    updatedAt: {
+                        type: string[];
+                    };
+                    reasonCodes: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            idempotencyKey: {
+                type: string;
+            };
+            approval: {
+                type: string;
+                enum: string[];
+            };
+            limit?: undefined;
+            cursor?: undefined;
+            filter?: undefined;
+            status?: undefined;
+            senderId?: undefined;
+            classification?: undefined;
+            search?: undefined;
+            includeEnrichment?: undefined;
+            includeReplyEligibility?: undefined;
+            versionId?: undefined;
+            body?: undefined;
+            approvedBody?: undefined;
+            approvedBodyHash?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: string;
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint: boolean;
+    };
+})[];
+export declare function searchInboxThreads(input: Record<string, unknown>): Promise<ToolResult<{
+    routeCalled: string;
+}>>;
+export declare function getInboxThread(input: Record<string, unknown>): Promise<ToolResult<any>>;
+export declare function checkInboxReplyEligibility(input: Record<string, unknown>): Promise<ToolResult<any>>;
+export declare function updateInboxDraft(input: Record<string, unknown>): Promise<ToolResult<any>>;
+export declare function sendInboxDraft(input: Record<string, unknown>): Promise<ToolResult<any>>;
+export declare function sendInboxManualReply(input: Record<string, unknown>): Promise<ToolResult<any>>;
+export {};