@noodleseed/one 0.176.0 → 0.178.0

package/node_modules/@noodle-borg/wire-contracts/dist/conversation-history.js

@@ -0,0 +1,192 @@
+import { z } from 'zod';
+/**
+ * Staff projection of durable conversation history (ADR 0241). Server output is strict; the tolerant
+ * `*ClientResponseSchema` variants let older clients ignore additive fields.
+ */
+export const ConversationIdSchema = z.string().regex(/^cv_[A-Za-z0-9_-]{8,64}$/);
+export const ConversationChannelSchema = z.enum(['website', 'whatsapp']);
+/** Staff review state; a failed tool outcome sets `needs_attention` automatically. */
+export const ConversationReviewStatusSchema = z.enum(['new', 'needs_attention', 'reviewed']);
+const SubjectRefSchema = z.string().min(1).max(256);
+/** Anonymous handles never leave the service; verified subjects carry the reference forget uses. */
+const ConversationSubjectSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('anonymous') }),
+    z.strictObject({ kind: z.literal('customer'), ref: SubjectRefSchema }),
+    z.strictObject({ kind: z.literal('participant'), ref: SubjectRefSchema }),
+]);
+export const ConversationSummarySchema = z.strictObject({
+    id: ConversationIdSchema,
+    channel: ConversationChannelSchema,
+    subject: ConversationSubjectSchema,
+    startedAt: z.iso.datetime(),
+    lastMessageAt: z.iso.datetime(),
+    itemCount: z.number().int().min(1),
+    reviewStatus: ConversationReviewStatusSchema,
+});
+export const ConversationItemSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('message'),
+        role: z.enum(['user', 'assistant']),
+        text: z.string().max(100_000),
+        at: z.iso.datetime(),
+    }),
+    z.strictObject({
+        kind: z.literal('outcome'),
+        interactionId: z.string().min(1).max(256),
+        tool: z.string().min(1).max(128),
+        status: z.enum(['succeeded', 'failed', 'declined', 'cancelled']),
+        at: z.iso.datetime(),
+    }),
+]);
+export const ConversationDetailSchema = z.strictObject({
+    ...ConversationSummarySchema.shape,
+    /** When the last visible item is removed automatically under the live retention window. */
+    expiresAt: z.iso.datetime(),
+    items: z.array(ConversationItemSchema).max(10_000),
+});
+const NoteTextSchema = z.string().trim().min(1).max(2000);
+/** A private staff note: never sent to the customer, never exported, removed with its conversation. */
+export const ConversationNoteSchema = z.strictObject({
+    author: z.string().min(1).max(500),
+    text: NoteTextSchema,
+    at: z.iso.datetime(),
+});
+/** Show adds the private notes that export leaves out. */
+export const ConversationShowSchema = z.strictObject({
+    ...ConversationDetailSchema.shape,
+    notes: z.array(ConversationNoteSchema).max(100),
+});
+const NextCursorSchema = z.string().min(1).max(2048);
+export const ConversationListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        conversations: z.array(ConversationSummarySchema).max(100),
+        nextCursor: NextCursorSchema.optional(),
+    }),
+});
+/** Show and review both answer with the conversation as staff now see it. */
+export const ConversationShowResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({ conversation: ConversationShowSchema }),
+});
+/** Review status needs `records:status`, a note `records:note`; at least one is required. */
+export const ConversationReviewRequestSchema = z
+    .strictObject({
+    reviewStatus: ConversationReviewStatusSchema.optional(),
+    note: NoteTextSchema.optional(),
+})
+    .refine((value) => value.reviewStatus !== undefined || value.note !== undefined, {
+    message: 'Set a review status or add a note.',
+});
+export const ConversationExportResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        conversations: z.array(ConversationDetailSchema).max(25),
+        nextCursor: NextCursorSchema.optional(),
+    }),
+});
+export const ConversationForgetRequestSchema = z.union([
+    z.strictObject({ conversationId: ConversationIdSchema }),
+    z.strictObject({
+        subject: z.strictObject({
+            kind: z.enum(['customer', 'participant']),
+            ref: SubjectRefSchema,
+        }),
+    }),
+]);
+export const ConversationForgetResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        forgotten: z.strictObject({
+            conversations: z.number().int().nonnegative(),
+            items: z.number().int().nonnegative(),
+        }),
+    }),
+});
+const ClientSubjectSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('anonymous') }),
+    z.object({ kind: z.literal('customer'), ref: SubjectRefSchema }),
+    z.object({ kind: z.literal('participant'), ref: SubjectRefSchema }),
+]);
+const ClientSummarySchema = z.object({
+    ...ConversationSummarySchema.shape,
+    subject: ClientSubjectSchema,
+});
+const ClientItemSchema = z.discriminatedUnion('kind', [
+    z.object(ConversationItemSchema.options[0].shape),
+    z.object(ConversationItemSchema.options[1].shape),
+]);
+const ClientDetailSchema = z.object({
+    ...ClientSummarySchema.shape,
+    expiresAt: ConversationDetailSchema.shape.expiresAt,
+    items: z.array(ClientItemSchema).max(10_000),
+});
+export const ConversationListClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({
+        conversations: z.array(ClientSummarySchema).max(100),
+        nextCursor: NextCursorSchema.optional(),
+    }),
+});
+export const ConversationShowClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({
+        conversation: z.object({
+            ...ClientDetailSchema.shape,
+            notes: z.array(z.object(ConversationNoteSchema.shape)).max(100),
+        }),
+    }),
+});
+export const ConversationExportClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({
+        conversations: z.array(ClientDetailSchema).max(25),
+        nextCursor: NextCursorSchema.optional(),
+    }),
+});
+export const ConversationForgetClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({
+        forgotten: z.object(ConversationForgetResponseSchema.shape.data.shape.forgotten.shape),
+    }),
+});
+/**
+ * The customer-backend projection (ADR 0241 decision 12): an embed client lists or forgets one of its
+ * own verified users, by the same `user.id` its session exchange sent. The tenant comes from the client
+ * credential, never the body; rows carry no subject and at most a short preview of the first question.
+ */
+const CustomerUserSchema = z.strictObject({ id: z.string().min(1).max(240) });
+export const ASSISTANT_CONVERSATION_PAGE_MAXIMUM = 50;
+export const ASSISTANT_CONVERSATION_PREVIEW_MAXIMUM = 120;
+export const AssistantConversationListRequestSchema = z.strictObject({
+    user: CustomerUserSchema,
+    limit: z.number().int().min(1).max(ASSISTANT_CONVERSATION_PAGE_MAXIMUM).optional(),
+    cursor: NextCursorSchema.optional(),
+});
+export const AssistantConversationForgetUserRequestSchema = z.strictObject({
+    user: CustomerUserSchema,
+});
+const AssistantConversationRowSchema = z.strictObject({
+    id: ConversationIdSchema,
+    channel: ConversationChannelSchema,
+    startedAt: z.iso.datetime(),
+    lastMessageAt: z.iso.datetime(),
+    preview: z.string().min(1).max(ASSISTANT_CONVERSATION_PREVIEW_MAXIMUM).optional(),
+});
+export const AssistantConversationListResponseSchema = z.strictObject({
+    ok: z.literal(true),
+    data: z.strictObject({
+        conversations: z.array(AssistantConversationRowSchema).max(ASSISTANT_CONVERSATION_PAGE_MAXIMUM),
+        nextCursor: NextCursorSchema.optional(),
+    }),
+});
+export const AssistantConversationListClientResponseSchema = z.object({
+    ok: z.literal(true),
+    data: z.object({
+        conversations: z
+            .array(z.object(AssistantConversationRowSchema.shape))
+            .max(ASSISTANT_CONVERSATION_PAGE_MAXIMUM),
+        nextCursor: NextCursorSchema.optional(),
+    }),
+});
+//# sourceMappingURL=conversation-history.js.map

package/node_modules/@noodle-borg/wire-contracts/dist/index.d.ts

@@ -391,9 +391,11 @@ export * from './application-activity.js';
 export * from './application-connections.js';
 export * from './application-draft-validation.js';
 export * from './application-drafts.js';
+export * from './application-history-settings.js';
 export * from './application-onboarding.js';
 export * from './billing-catalog.js';
 export * from './business-workspaces.js';
+export * from './conversation-history.js';
 export * from './deployment-deletion.js';
 export * from './native-record-lifecycle.js';
 export * from './operation-coordination.js';

package/node_modules/@noodle-borg/wire-contracts/dist/index.js

@@ -230,9 +230,11 @@ export * from './application-activity.js';
 export * from './application-connections.js';
 export * from './application-draft-validation.js';
 export * from './application-drafts.js';
+export * from './application-history-settings.js';
 export * from './application-onboarding.js';
 export * from './billing-catalog.js';
 export * from './business-workspaces.js';
+export * from './conversation-history.js';
 export * from './deployment-deletion.js';
 export * from './native-record-lifecycle.js';
 export * from './operation-coordination.js';

package/node_modules/@noodle-borg/wire-contracts/dist/whatsapp.d.ts

@@ -359,11 +359,11 @@ export declare const WhatsAppEventsResponseSchema: z.ZodObject<{
             queued: "queued";
             running: "running";
             failed: "failed";
+            cancelled: "cancelled";
             delivered: "delivered";
             reply: "reply";
             sending: "sending";
             refused: "refused";
-            cancelled: "cancelled";
         }>;
         eventAt: z.ZodNumber;
         receivedAt: z.ZodNumber;
@@ -386,11 +386,11 @@ export declare const WhatsAppEventsClientResponseSchema: z.ZodObject<{
             queued: "queued";
             running: "running";
             failed: "failed";
+            cancelled: "cancelled";
             delivered: "delivered";
             reply: "reply";
             sending: "sending";
             refused: "refused";
-            cancelled: "cancelled";
         }>;
         eventAt: z.ZodNumber;
         receivedAt: z.ZodNumber;

package/node_modules/@noodleseed/assistant/README.md

@@ -626,6 +626,25 @@ replay across sessions. React applications may observe recovery and structured f
 `createAssistantSession` returns the opaque token, expiry, resolved non-secret configuration, and explicit
 turn/interaction endpoint URLs. Forward that response unchanged to the component or headless client.
 
+#### Your users' conversation history
+
+When the business records conversations, the same backend credential lists or erases one signed-in user's
+chats. Pass the exact `user.id` your session exchange sends; the client's application environment is the
+only scope, so one customer's backend never reaches another's history.
+
+```ts
+import { forgetUser, listConversations } from "@noodleseed/assistant/server";
+
+const credentials = { serviceUrl, clientId, clientSecret };
+// A "your chats" view: newest first, each with a short preview of the first question.
+const page = await listConversations({ ...credentials, user: { id: account.id }, limit: 20 });
+// In your own account deletion. Idempotent, so a retry after a 5xx is safe.
+await forgetUser({ ...credentials, user: { id: account.id } });
+```
+
+`forgetUser` erases stored conversation history only; a live session's short-lived working memory is not
+touched and expires within two hours. Failures throw `AssistantConversationsError` with a typed `detail` (`status`, `retryable`, `serviceCode`).
+
 The MCP server's top-level `branding` block is the portable deployment source for identity and colors shared
 by widgets and the assistant. The embedding application may use the typed `appearance` object when it needs
 exact control over assistant-specific roles:

package/node_modules/@noodleseed/assistant/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/assistant",
-  "version": "1.36.1",
+  "version": "1.37.0",
   "description": "Embed the Noodle Seed customer-branded assistant in your web app with managed or framework-owned UI, a framework-neutral MCP App host, a DOM-free client, and a backend session helper. Authoring and deploying the server is @noodleseed/one.",
   "license": "Apache-2.0",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/one",
-  "version": "0.176.0",
+  "version": "0.178.0",
   "private": false,
   "description": "Noodle CLI by Noodle Seed — author, run, and deploy declarative MCP servers. Embedding the assistant in your own web app is @noodleseed/assistant.",
   "license": "Apache-2.0",
@@ -236,7 +236,7 @@
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/server": "2.0.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.107.0",
+    "@noodle-borg/agent-kit": "0.108.0",
     "@noodle-borg/app-audit": "0.0.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",