@takeshape/schema 12.1.1 → 12.1.5

package/dist/resolvers/ai/agent-chat-response.d.ts

@@ -0,0 +1,366 @@
+import type { FromSchema } from 'json-schema-to-ts';
+export declare const shapeName = "TSChatResponse";
+export declare const schema: {
+    readonly properties: {
+        readonly output: {
+            readonly type: "object";
+            readonly properties: {
+                readonly content: {
+                    readonly type: "string";
+                    readonly description: "The string content of the chat message.";
+                };
+                readonly references: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly '@ref': "TSReference";
+                    };
+                    readonly description: "A list of references associated with the chat message.";
+                };
+                readonly artifact: {
+                    readonly type: "object";
+                    readonly description: "An optional artifact associated with the chat message.";
+                };
+            };
+            readonly required: ["references"];
+            readonly additionalProperties: false;
+        };
+        readonly messageId: {
+            readonly type: "string";
+            readonly description: "The unique identifier for the agent run response message.";
+        };
+        readonly input: {
+            readonly title: "TSAgentMessageInput";
+            readonly description: "The input schema for agent messages.";
+            readonly discriminator: {
+                readonly propertyName: "type";
+            };
+            readonly oneOf: [{
+                readonly title: "TSAgentMessageUnknownInput";
+                readonly type: "object";
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "unknown";
+                    };
+                    readonly data: {};
+                };
+                readonly required: ["type", "data"];
+                readonly additionalProperties: false;
+            }, {
+                readonly title: "TSAgentMessageStringInput";
+                readonly type: "object";
+                readonly properties: {
+                    readonly type: {
+                        readonly const: "string";
+                    };
+                    readonly content: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: ["type", "content"];
+                readonly additionalProperties: false;
+            }];
+        };
+        readonly session: {
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                    readonly description: "The unique identifier for the agent session.";
+                };
+                readonly createdAt: {
+                    readonly type: "string";
+                    readonly description: "ISO8601 timestamp when the agent session was created";
+                    readonly format: "date-time";
+                };
+                readonly updatedAt: {
+                    readonly type: "string";
+                    readonly description: "ISO8601 timestamp when the agent session was updated";
+                    readonly format: "date-time";
+                };
+                readonly agentName: {
+                    readonly type: "string";
+                    readonly description: "The name of the agent associated with this session.";
+                };
+                readonly projectId: {
+                    readonly type: "string";
+                    readonly description: "The ID of the project to which this agent session belongs.";
+                };
+                readonly schemaId: {
+                    readonly type: "string";
+                    readonly description: "The schema ID associated with the agent session, typically in the format \"production~projectId\".";
+                };
+                readonly schemaHash: {
+                    readonly type: "string";
+                    readonly description: "The hash of the schema version associated with the agent session.";
+                };
+                readonly done: {
+                    readonly type: "boolean";
+                    readonly description: "Indicates whether the agent session is completed.";
+                };
+                readonly suspended: {
+                    readonly type: "boolean";
+                    readonly description: "Indicates whether the agent session is suspended.";
+                };
+                readonly previousStateId: {
+                    readonly type: "string";
+                    readonly description: "The ID of the previous state in the agent session, if any.";
+                };
+                readonly currentStateId: {
+                    readonly type: "string";
+                    readonly description: "The ID of the current state in the agent session.";
+                };
+                readonly chatSessionIds: {
+                    readonly type: "object";
+                    readonly description: "A mapping of chat session IDs to their corresponding state IDs.";
+                };
+                readonly sessionMemory: {
+                    readonly type: "object";
+                    readonly description: "Memory associated with the agent session, which can be used to store stateful information.";
+                };
+                readonly hasAgentHistory: {
+                    readonly type: "boolean";
+                    readonly description: "Indicates whether the agent session has an associated history of agent responses.";
+                };
+                readonly hasFeedback: {
+                    readonly type: "boolean";
+                    readonly description: "Indicates whether the agent session has any messages with feedback.";
+                };
+                readonly suspend: {
+                    readonly type: "boolean";
+                    readonly description: "Indicates whether the agent session is suspended.";
+                };
+                readonly suspendedTransitionIndices: {
+                    readonly type: "array";
+                    readonly description: "An array of indices of suspended transitions in the agent session.";
+                    readonly items: {
+                        readonly type: "integer";
+                    };
+                };
+                readonly firstMessageInput: {
+                    readonly title: "TSAgentMessageInput";
+                    readonly description: "The input schema for agent messages.";
+                    readonly discriminator: {
+                        readonly propertyName: "type";
+                    };
+                    readonly oneOf: [{
+                        readonly title: "TSAgentMessageUnknownInput";
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "unknown";
+                            };
+                            readonly data: {};
+                        };
+                        readonly required: ["type", "data"];
+                        readonly additionalProperties: false;
+                    }, {
+                        readonly title: "TSAgentMessageStringInput";
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "string";
+                            };
+                            readonly content: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly required: ["type", "content"];
+                        readonly additionalProperties: false;
+                    }];
+                };
+                readonly lastMessageOutput: {
+                    readonly title: "TSAgentMessageOutput";
+                    readonly description: "The output schema for agent messages.";
+                    readonly discriminator: {
+                        readonly propertyName: "type";
+                    };
+                    readonly oneOf: [{
+                        readonly title: "TSAgentGenerateStateOutput";
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "generate";
+                            };
+                            readonly data: {};
+                        };
+                        readonly required: ["type", "data"];
+                        readonly additionalProperties: false;
+                    }, {
+                        readonly title: "TSAgentGraphQLStateOutput";
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "graphql";
+                            };
+                            readonly data: {};
+                        };
+                        readonly required: ["type", "data"];
+                        readonly additionalProperties: false;
+                    }, {
+                        readonly title: "TSAgentChatStateOutput";
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "chat";
+                            };
+                            readonly data: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly content: {
+                                        readonly type: "string";
+                                    };
+                                    readonly artifact: {
+                                        readonly type: "object";
+                                    };
+                                    readonly references: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                            readonly properties: {
+                                                readonly _tid: {
+                                                    readonly type: "string";
+                                                };
+                                            };
+                                            readonly required: ["_tid"];
+                                            readonly additionalProperties: false;
+                                        };
+                                    };
+                                };
+                                readonly required: ["content", "references"];
+                                readonly additionalProperties: false;
+                            };
+                        };
+                        readonly required: ["type", "data"];
+                        readonly additionalProperties: false;
+                    }, {
+                        readonly title: "TSAgentUnknownStateOutput";
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "unknown";
+                            };
+                            readonly data: {};
+                        };
+                        readonly required: ["type", "data"];
+                        readonly additionalProperties: false;
+                    }];
+                };
+                readonly totalTokens: {
+                    readonly type: "number";
+                    readonly description: "The total number of tokens used in the agent session.";
+                };
+                readonly domain: {
+                    readonly type: "string";
+                    readonly description: "The domain from which the agent session was created (e.g., \"shop.example.com\", \"app.takeshape.io\").";
+                };
+                readonly takeshapeUserId: {
+                    readonly type: "string";
+                    readonly description: "The TakeShape user ID if the session was created by a TakeShape user (via JWT or PAT).";
+                };
+                readonly usage: {
+                    readonly type: "array";
+                    readonly description: "Itemized token usage breakdown by service and model across all messages";
+                    readonly items: {
+                        readonly title: "TSAiUsageItem";
+                        readonly type: "object";
+                        readonly description: "Token usage breakdown for a single service and model";
+                        readonly properties: {
+                            readonly service: {
+                                readonly type: "string";
+                                readonly description: "The AI service provider (e.g., \"openai\", \"anthropic\")";
+                            };
+                            readonly model: {
+                                readonly type: "string";
+                                readonly description: "The model identifier (e.g., \"gpt-4\", \"claude-3-opus\")";
+                            };
+                            readonly inputTokens: {
+                                readonly type: "number";
+                                readonly description: "Number of input/prompt tokens consumed";
+                            };
+                            readonly outputTokens: {
+                                readonly type: "number";
+                                readonly description: "Number of output/completion tokens generated";
+                            };
+                            readonly totalTokens: {
+                                readonly type: "number";
+                                readonly description: "Total tokens (input + output)";
+                            };
+                            readonly inputTokenDetails: {
+                                readonly type: "object";
+                                readonly description: "Detailed breakdown of input token usage";
+                                readonly properties: {
+                                    readonly noCacheTokens: {
+                                        readonly type: "number";
+                                        readonly description: "Tokens not using cache";
+                                    };
+                                    readonly cacheReadTokens: {
+                                        readonly type: "number";
+                                        readonly description: "Tokens served from cache";
+                                    };
+                                    readonly cacheWriteTokens: {
+                                        readonly type: "number";
+                                        readonly description: "Tokens written to cache";
+                                    };
+                                };
+                            };
+                            readonly outputTokenDetails: {
+                                readonly type: "object";
+                                readonly description: "Detailed breakdown of output token usage";
+                                readonly properties: {
+                                    readonly textTokens: {
+                                        readonly type: "number";
+                                        readonly description: "Regular text output tokens";
+                                    };
+                                    readonly reasoningTokens: {
+                                        readonly type: "number";
+                                        readonly description: "Extended thinking tokens";
+                                    };
+                                };
+                            };
+                            readonly guardrailUnits: {
+                                readonly type: "number";
+                                readonly description: "Number of guardrail units consumed";
+                            };
+                        };
+                        readonly required: ["service", "model"];
+                        readonly additionalProperties: false;
+                    };
+                };
+            };
+            readonly required: ["id", "agentName", "createdAt", "updatedAt", "done", "currentStateId", "chatSessionIds", "sessionMemory", "hasAgentHistory", "hasFeedback", "suspend", "projectId", "schemaId", "schemaHash", "totalTokens"];
+            readonly additionalProperties: false;
+            readonly title: "TSAgentSession";
+            readonly type: "object";
+        };
+        readonly runMode: {
+            readonly enum: ["BACKGROUND", "IMMEDIATE"];
+            readonly description: "Indicates how the agent message was run";
+        };
+    };
+    readonly type: "object";
+    readonly required: ["messageId", "session", "runMode"];
+    readonly additionalProperties: true;
+};
+export type AgentChatResponse = FromSchema<typeof schema>;
+export declare function createUserShapeSchema(): {
+    properties: {
+        output: import("../../index.ts").PropertySchema | import("../../index.ts").RefSchema;
+        input: {
+            '@ref': string;
+        };
+        session: {
+            '@ref': string;
+        };
+        messageId: {
+            readonly type: "string";
+            readonly description: "The unique identifier for the agent run response message.";
+        };
+        runMode: {
+            readonly enum: ["BACKGROUND", "IMMEDIATE"];
+            readonly description: "Indicates how the agent message was run";
+        };
+    };
+    required: ["messageId", "session", "runMode"];
+    additionalProperties: false;
+    type: "object";
+};

package/dist/resolvers/ai/agent-chat-response.js

@@ -0,0 +1,21 @@
+import * as agentChatPayload from "./agent-chat-payload.js";
+import * as sendAgentMessageResponse from "./send-agent-message-response.js";
+export const shapeName = 'TSChatResponse';
+export const schema = {
+    ...sendAgentMessageResponse.schema,
+    properties: {
+        ...sendAgentMessageResponse.schema.properties,
+        output: {
+            ...agentChatPayload.schema
+        }
+    }
+};
+export function createUserShapeSchema() {
+    return sendAgentMessageResponse.createUserShapeSchema({
+        properties: {
+            output: {
+                '@ref': agentChatPayload.shapeName
+            }
+        }
+    });
+}

package/dist/resolvers/ai/agent-generate-args.d.ts

@@ -0,0 +1,62 @@
+import type { FromSchema } from 'json-schema-to-ts';
+export declare const shapeName = "TSGenerateArgs";
+export declare const schema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly input: {
+            readonly type: "string";
+            readonly description: "The generate message input from the user.";
+        };
+        readonly attachments: {
+            readonly type: "array";
+            readonly description: "Optional attachments to send with the generate message. Supported media types depends on LLM";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly data: {
+                        readonly type: "string";
+                        readonly description: "A base64 encoded string of the attachment data.";
+                    };
+                    readonly filename: {
+                        readonly type: "string";
+                        readonly description: "The optional filename of the attachment.";
+                    };
+                    readonly mediaType: {
+                        readonly type: "string";
+                        readonly description: "IANA media type of the file.\n\n@see https://www.iana.org/assignments/media-types/media-types.xhtml";
+                    };
+                };
+                readonly required: ["data", "mediaType"];
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly required: ["input"];
+    readonly additionalProperties: false;
+};
+export type AgentGenerateArgs = FromSchema<typeof schema>;
+export declare const shapeSchema: {
+    properties: {
+        attachments: {
+            type: string;
+            items: {
+                '@ref': string;
+            };
+        };
+        input: {
+            readonly type: "string";
+            readonly description: "The generate message input from the user.";
+        };
+    };
+    type: "object";
+    required: ["input"];
+    additionalProperties: false;
+};
+export declare const validate: import("ajv").ValidateFunction<{
+    attachments?: {
+        filename?: string | undefined;
+        data: string;
+        mediaType: string;
+    }[] | undefined;
+    input: string;
+}>;

package/dist/resolvers/ai/agent-generate-args.js

@@ -0,0 +1,30 @@
+import { createTypedValidator } from '@takeshape/json-schema';
+import * as agentAttachment from "./agent-attachment.js";
+export const shapeName = 'TSGenerateArgs';
+export const schema = {
+    type: 'object',
+    properties: {
+        input: {
+            type: 'string',
+            description: 'The generate message input from the user.'
+        },
+        attachments: {
+            type: 'array',
+            description: 'Optional attachments to send with the generate message. Supported media types depends on LLM',
+            items: agentAttachment.schema
+        }
+    },
+    required: ['input'],
+    additionalProperties: false
+};
+export const shapeSchema = {
+    ...schema,
+    properties: {
+        ...schema.properties,
+        attachments: {
+            type: 'array',
+            items: { '@ref': agentAttachment.shapeName }
+        }
+    }
+};
+export const validate = createTypedValidator(schema);

package/dist/resolvers/ai/agent-message-input.d.ts

@@ -0,0 +1,73 @@
+import type { FromSchema } from 'json-schema-to-ts';
+export declare const shapeName = "TSAgentMessageInput";
+export declare const unknownInputSchema: {
+    readonly title: "TSAgentMessageUnknownInput";
+    readonly type: "object";
+    readonly properties: {
+        readonly type: {
+            readonly const: "unknown";
+        };
+        readonly data: {};
+    };
+    readonly required: ["type", "data"];
+    readonly additionalProperties: false;
+};
+export declare const stringInputSchema: {
+    readonly title: "TSAgentMessageStringInput";
+    readonly type: "object";
+    readonly properties: {
+        readonly type: {
+            readonly const: "string";
+        };
+        readonly content: {
+            readonly type: "string";
+        };
+    };
+    readonly required: ["type", "content"];
+    readonly additionalProperties: false;
+};
+export declare const schema: {
+    readonly title: "TSAgentMessageInput";
+    readonly description: "The input schema for agent messages.";
+    readonly discriminator: {
+        readonly propertyName: "type";
+    };
+    readonly oneOf: [{
+        readonly title: "TSAgentMessageUnknownInput";
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly const: "unknown";
+            };
+            readonly data: {};
+        };
+        readonly required: ["type", "data"];
+        readonly additionalProperties: false;
+    }, {
+        readonly title: "TSAgentMessageStringInput";
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly const: "string";
+            };
+            readonly content: {
+                readonly type: "string";
+            };
+        };
+        readonly required: ["type", "content"];
+        readonly additionalProperties: false;
+    }];
+};
+export type AgentMessageInput = FromSchema<typeof schema>;
+export declare const shapeSchema: {
+    readonly oneOf: [{
+        readonly '@ref': "TSAgentMessageUnknownInput";
+    }, {
+        readonly '@ref': "TSAgentMessageStringInput";
+    }];
+    readonly title: "TSAgentMessageInput";
+    readonly description: "The input schema for agent messages.";
+    readonly discriminator: {
+        readonly propertyName: "type";
+    };
+};

package/dist/resolvers/ai/agent-message-input.js

@@ -0,0 +1,39 @@
+export const shapeName = 'TSAgentMessageInput';
+export const unknownInputSchema = {
+    title: 'TSAgentMessageUnknownInput',
+    type: 'object',
+    properties: {
+        type: {
+            const: 'unknown'
+        },
+        data: {}
+    },
+    required: ['type', 'data'],
+    additionalProperties: false
+};
+export const stringInputSchema = {
+    title: 'TSAgentMessageStringInput',
+    type: 'object',
+    properties: {
+        type: {
+            const: 'string'
+        },
+        content: {
+            type: 'string'
+        }
+    },
+    required: ['type', 'content'],
+    additionalProperties: false
+};
+export const schema = {
+    title: shapeName,
+    description: 'The input schema for agent messages.',
+    discriminator: {
+        propertyName: 'type'
+    },
+    oneOf: [unknownInputSchema, stringInputSchema]
+};
+export const shapeSchema = {
+    ...schema,
+    oneOf: [{ '@ref': unknownInputSchema.title }, { '@ref': stringInputSchema.title }]
+};