@taiga-ai/mcp-server 0.16.0-dev.433 → 0.16.0-dev.435

package/dist/index.js

@@ -1395,6 +1395,193 @@ function createdInitiativesOf(result) {
 	return parsed.success ? parsed.data.createdInitiatives : null;
 }
 //#endregion
+//#region ../../packages/types/dist/chat-stream-events.js
+/**
+* The longest generated document, in UTF-16 units: a long brief of a dozen
+* pages. A document past it is refused by the agent rather than clipped, since
+* a document with its tail cut off reads as finished.
+*/
+const MAX_GENERATED_DOCUMENT_CHARS = 4e4;
+/** A JSON object whose keys a reader walks itself. */
+const jsonObject = z.record(z.string(), z.unknown());
+/** The raw Strands block a tool call starts in. */
+const contentBlockStart = z.object({ start: lenient(z.object({ toolUse: lenient(jsonObject) })) });
+/** A raw Strands delta: answer text, or a fragment of a tool's input. */
+const contentBlockDelta = z.object({ delta: lenient(z.object({
+	text: lenient(z.string()),
+	toolUse: lenient(jsonObject)
+})) });
+/**
+* A frame's `event`, with the keys a reader dispatches on named. The raw
+* Strands blocks are read here; each synthesized payload is left as it came
+* and parsed by the reader that acts on it. Every other key passes through.
+*/
+const chatStreamFrameEvent = z.looseObject({
+	contentBlockStart: lenient(contentBlockStart),
+	contentBlockDelta: lenient(contentBlockDelta),
+	toolStatus: z.unknown().optional(),
+	retry: z.unknown().optional(),
+	citations: z.unknown().optional(),
+	citationCheck: z.unknown().optional(),
+	usage: z.unknown().optional(),
+	thought: z.unknown().optional(),
+	plan: z.unknown().optional(),
+	readPause: z.unknown().optional(),
+	initiativeProposal: z.unknown().optional(),
+	initiativeEditProposal: z.unknown().optional(),
+	generatedDocument: z.unknown().optional(),
+	documentSections: z.unknown().optional(),
+	specUpdate: z.unknown().optional(),
+	flowSections: z.unknown().optional()
+});
+z.object({
+	status: z.unknown().optional(),
+	error: lenient(z.string()),
+	code: lenient(z.string()),
+	message: lenient(z.object({
+		role: z.unknown().optional(),
+		content: lenient(z.array(z.unknown()))
+	})),
+	event: lenient(chatStreamFrameEvent)
+});
+//#endregion
+//#region ../../packages/types/dist/chat-stream-payloads.js
+/**
+* The synthesized chat stream payloads that the API persists and the browser
+* renders, each read by ONE set of rules (PRO-2735).
+*
+* The API reads a payload before it saves it with the answer, and the browser
+* reads it again, live and from the saved message. The two copies of these
+* readers used to be kept in step by hand (`chat/routes/stream.ts`,
+* `product-chat/live-turn.ts`); one shared reader means the card a live
+* stream draws is the card the reloaded transcript draws.
+*
+* Each reader takes the payload (the value under its key in `event`, or in the
+* message metadata) and returns the checked value or null. A payload that
+* fails is dropped whole, never stored half understood: every one of them is
+* rendered from the metadata, and the proposals' buttons perform a write.
+*/
+/**
+* The bounds `createBacklogItemBody` enforces on a proposed initiative
+* (PRO-1879). A proposal outside them would draw a card whose button opens a
+* dialog the create refuses; the agent applies them too, so a value outside
+* them is a malformed frame rather than a long brief to trim.
+*/
+const MAX_PROPOSAL_TITLE_CHARS = 500;
+const MAX_PROPOSAL_DESCRIPTION_CHARS = 2e4;
+/** `updateBacklogItemBody`'s own bound on a description. */
+const MAX_EDIT_DESCRIPTION_CHARS = 2e4;
+/** Text that is not empty once trimmed and fits `max` as written. */
+function contentWithin(max) {
+	return z.string().refine((text) => text.trim().length > 0 && text.length <= max);
+}
+/** `revision` counts only as the literal `true`; anything else leaves it off. */
+function revisionOf(revision) {
+	return revision === true ? { revision: true } : {};
+}
+z.object({
+	title: z.string().trim().min(1).max(MAX_PROPOSAL_TITLE_CHARS),
+	description: z.string().trim().min(1).max(MAX_PROPOSAL_DESCRIPTION_CHARS),
+	productId: z.string().trim().min(1),
+	revision: z.unknown().optional()
+}).transform(({ revision, ...proposal }) => ({
+	...proposal,
+	...revisionOf(revision)
+}));
+z.object({
+	initiativeId: z.string().trim().min(1),
+	description: contentWithin(MAX_EDIT_DESCRIPTION_CHARS),
+	basedOn: z.object({
+		updatedAt: z.string().trim().min(1),
+		descriptionHash: z.string().regex(/^[0-9a-f]{64}$/)
+	})
+});
+z.object({
+	title: z.string().trim().min(1).max(200),
+	kind: z.string().trim().min(1).max(80),
+	markdown: contentWithin(MAX_GENERATED_DOCUMENT_CHARS),
+	revision: z.unknown().optional()
+}).transform(({ revision, ...document }) => ({
+	...document,
+	...revisionOf(revision)
+}));
+const UNSUPPORTED_REASONS = [
+	"no_quote",
+	"unsupplied_document",
+	"not_in_document"
+];
+const OUTCOMES = [
+	"verified",
+	"paraphrase_supported",
+	"repointed",
+	"unsupported"
+];
+/**
+* A reason a newer agent sends, or the `quote_not_found` an agent before
+* PRO-1752 sent, still names an unsupported statement; either reads as the
+* least specific reason.
+*/
+function unsupportedReason(value) {
+	return UNSUPPORTED_REASONS.find((reason) => reason === value) ?? "not_in_document";
+}
+/**
+* Which document timeline an entry names (PRO-1731). Absent from an agent
+* older than PRO-1731, and absent means plan; left off rather than written in,
+* so "did not say" stays distinguishable from "said plan". A timeline this
+* contract does not know fails the entry: the origin decides which document a
+* chip opens, and reading an unknown one as plan links to words that are not
+* there.
+*/
+const origin = z.enum(PRODUCT_DOCUMENT_ORIGINS).optional();
+/** One statement the check could not support; a missing reason is malformed. */
+const unverifiedCitation = z.object({
+	documentType: z.string(),
+	version: z.number(),
+	origin,
+	section: lenient(z.string()),
+	reason: z.string()
+}).transform((u) => ({
+	documentType: u.documentType,
+	version: u.version,
+	...u.origin === void 0 ? {} : { origin: u.origin },
+	...u.section === void 0 ? {} : { section: u.section },
+	reason: unsupportedReason(u.reason)
+}));
+/**
+* One marker's outcome, strictly: an entry with no 1-based marker index, no
+* source, or an outcome this contract does not name is dropped rather than
+* guessed at, because the outcome decides whether the claim renders as a
+* reference at all.
+*/
+const citationOutcome = z.object({
+	markerIndex: z.number().refine((n) => Number.isInteger(n) && n >= 1),
+	documentType: z.string(),
+	version: z.number(),
+	origin,
+	section: lenient(z.string()),
+	outcome: z.enum(OUTCOMES),
+	reason: z.unknown().optional(),
+	resolvedSection: lenient(z.string())
+}).transform((o) => ({
+	markerIndex: o.markerIndex,
+	documentType: o.documentType,
+	version: o.version,
+	...o.origin === void 0 ? {} : { origin: o.origin },
+	...o.section === void 0 ? {} : { section: o.section },
+	outcome: o.outcome,
+	...o.outcome === "unsupported" ? { reason: unsupportedReason(o.reason) } : {},
+	...o.resolvedSection === void 0 ? {} : { resolvedSection: o.resolvedSection }
+}));
+z.object({
+	verified: z.number(),
+	unverified: lenientList(unverifiedCitation),
+	outcomes: lenientList(citationOutcome).catch([]).optional()
+}).transform(({ verified, unverified, outcomes }) => ({
+	verified: Math.max(0, Math.trunc(verified)),
+	unverified,
+	...outcomes === void 0 ? {} : { outcomes }
+}));
+//#endregion
 //#region ../../packages/types/dist/environments.js
 const ENVIRONMENT_TYPES = [
 	"development",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.16.0-dev.433",
+  "version": "0.16.0-dev.435",
   "description": "MCP server for Taiga -- gives AI assistants access to documents and products",
   "type": "module",
   "main": "./dist/index.js",