@takeshape/schema 11.133.4 → 11.142.5

package/dist/agents.d.ts

@@ -19,14 +19,12 @@ export declare const EXECUTION_TYPE_CHAT = "chat";
 export declare const EXECUTION_TYPE_GENERATE = "generate";
 export declare const EXECUTION_TYPE_GRAPHQL = "graphql";
 export declare function getAgentEndStates(agent: AgentJSON, includeSuspend?: boolean): Set<string>;
-export declare const getSendAgentMessageShapeName: (agentName: string) => string;
-export declare const getAgentMessageShapeName: (inputName: string) => string;
 export declare const getCreateAgentSessionMutationName: (agentName: string) => string;
 export declare const getInspectAgentQueryName: (agentName: string) => string;
 export declare const getSendAgentFeedbackMutationName: (agentName: string) => string;
+export declare const getGetAgentMessageQueryName: (agentName: string) => string;
+export declare const getAbortAgentMessageMutationName: (agentName: string) => string;
 export declare const getSendAgentMessageMutationName: (inputName: string) => string;
-export declare const getGetAgentMessageQueryName: (inputName: string) => string;
-export declare const getAbortAgentMessageMutationName: (inputName: string) => string;
 export declare function getAgentFeatures(agents: AgentMap): Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'shapes'>;
 export declare function isValidAgentMutation(projectSchema: ProjectSchemaJSON, name: string): boolean;
 export declare function addAiQueries(projectSchema: ProjectSchemaJSON): ProjectSchemaJSON;

package/dist/agents.js

@@ -5,7 +5,7 @@ import uniq from 'lodash/uniq.js';
 import upperFirst from 'lodash/upperFirst.js';
 import * as abortAgentMessageResponse from "./resolvers/ai/abort-agent-message-response.js";
 import * as agentChatPayload from "./resolvers/ai/agent-chat-payload.js";
-import * as createAgentSessionResponse from "./resolvers/ai/create-agent-session-response.js";
+import * as agentSessionPayload from "./resolvers/ai/agent-session-payload.js";
 import * as getAgentMessageArgs from "./resolvers/ai/get-agent-message-args.js";
 import * as getAgentMessageResponse from "./resolvers/ai/get-agent-message-response.js";
 import * as inspectAgentArgs from "./resolvers/ai/inspect-agent-args.js";
@@ -60,12 +60,7 @@ export function getAgentEndStates(agent, includeSuspend = false) {
     }
     return endStates;
 }
-export const getSendAgentMessageShapeName = (agentName) => {
-    return `${upperFirst(agentName)}SendAgentMessageResponse`;
-};
-export const getAgentMessageShapeName = (inputName) => {
-    return `${upperFirst(inputName)}AgentMessage`;
-};
+// Agent Scoped Names
 export const getCreateAgentSessionMutationName = (agentName) => {
     return `create${upperFirst(agentName)}Session`;
 };
@@ -75,21 +70,31 @@ export const getInspectAgentQueryName = (agentName) => {
 export const getSendAgentFeedbackMutationName = (agentName) => {
     return `send${upperFirst(agentName)}Feedback`;
 };
-export const getSendAgentMessageMutationName = (inputName) => {
-    return `send${upperFirst(inputName)}Message`;
+export const getGetAgentMessageQueryName = (agentName) => {
+    return `get${upperFirst(agentName)}Message`;
 };
-export const getGetAgentMessageQueryName = (inputName) => {
-    return `get${upperFirst(inputName)}Message`;
+export const getAbortAgentMessageMutationName = (agentName) => {
+    return `abort${upperFirst(agentName)}Message`;
 };
-export const getAbortAgentMessageMutationName = (inputName) => {
-    return `abort${upperFirst(inputName)}Message`;
+// Agent Input Scopes Names
+export const getSendAgentMessageMutationName = (inputName) => {
+    return `send${upperFirst(inputName)}Message`;
 };
+function createAssertValidName(key, result) {
+    const singular = key === 'shapes' ? 'shape' : key === 'mutations' ? 'mutation' : 'query';
+    return (name) => {
+        assert(result[key][name] === undefined, `Schema already has a ${singular} with the name "${name}"`);
+    };
+}
 export function getAgentFeatures(agents) {
     const result = {
         queries: {},
         mutations: {},
         shapes: {}
     };
+    const assertValidShapeName = createAssertValidName('shapes', result);
+    const assertValidQueryName = createAssertValidName('queries', result);
+    const assertValidMutationName = createAssertValidName('mutations', result);
     for (const [agentName, agent] of Object.entries(agents)) {
         // Get valid return types based on states that could possibly be the end state
         // TODO In the future the agent will have a return type defined and we will instead validate
@@ -105,50 +110,113 @@ export function getAgentFeatures(agents) {
             }
             return JSON_SHAPE_NAME;
         }));
-        const shape = returnTypes.length === 0 ? 'string' : returnTypes.length === 1 ? returnTypes[0] : JSON_SHAPE_NAME;
-        const sendAgentMessageResponseShapeName = getSendAgentMessageShapeName(agentName);
-        assert(result.shapes[sendAgentMessageResponseShapeName] === undefined, `Schema already has a shape with the name "${sendAgentMessageResponseShapeName}"`);
+        const agentOutput = returnTypes.length === 0 ? 'string' : returnTypes.length === 1 ? returnTypes[0] : JSON_SHAPE_NAME;
+        const agentOutputSchema = agentOutput === 'string' ? { type: 'string' } : { '@ref': agentOutput };
+        const agentSessionShapeName = agentSessionPayload.shapeName;
+        const agentMessageShapeName = getAgentMessageResponse.createUserShapeName(agentName);
+        assertValidShapeName(agentMessageShapeName);
+        result.shapes[agentMessageShapeName] = {
+            id: agentMessageShapeName,
+            name: agentMessageShapeName,
+            title: agentMessageShapeName,
+            schema: getAgentMessageResponse.createUserShapeSchema({
+                properties: {
+                    output: agentOutputSchema
+                }
+            })
+        };
+        const sendAgentMessageResponseShapeName = sendAgentMessageResponse.createUserShapeName(agentName);
+        assertValidShapeName(sendAgentMessageResponseShapeName);
         result.shapes[sendAgentMessageResponseShapeName] = {
             id: sendAgentMessageResponseShapeName,
             name: sendAgentMessageResponseShapeName,
             title: sendAgentMessageResponseShapeName,
-            schema: {
-                type: 'object',
+            schema: sendAgentMessageResponse.createUserShapeSchema({
                 properties: {
-                    ...sendAgentMessageResponse.schema.properties,
-                    output: {
-                        '@ref': shape
-                    }
-                },
-                required: [...sendAgentMessageResponse.schema.required],
-                additionalProperties: false
+                    output: agentOutputSchema
+                }
+            })
+        };
+        const inspectAgentResponseShapeName = inspectAgentResponse.createUserShapeName(agentName);
+        assertValidShapeName(inspectAgentResponseShapeName);
+        result.shapes[inspectAgentResponseShapeName] = {
+            id: inspectAgentResponseShapeName,
+            name: inspectAgentResponseShapeName,
+            title: inspectAgentResponseShapeName,
+            schema: inspectAgentResponse.createUserShapeSchema()
+        };
+        const getAgentMessageQueryName = getGetAgentMessageQueryName(agentName);
+        assertValidQueryName(getAgentMessageQueryName);
+        result.queries[getAgentMessageQueryName] = {
+            description: `Get a message for the ${agentName} agent`,
+            shape: agentMessageShapeName,
+            resolver: {
+                name: 'ai:getAgentMessage',
+                agentName
+            },
+            args: {
+                ...getAgentMessageArgs.schema
+            }
+        };
+        const abortAgentMessageMutationName = getAbortAgentMessageMutationName(agentName);
+        assertValidMutationName(abortAgentMessageMutationName);
+        result.mutations[abortAgentMessageMutationName] = {
+            description: `Abort a message for the ${agentName} agent`,
+            shape: abortAgentMessageResponse.shapeName,
+            resolver: {
+                name: 'ai:abortAgentMessage',
+                agentName
+            },
+            args: {
+                ...getAgentMessageArgs.schema
             }
         };
         const createAgentSessionMutationName = getCreateAgentSessionMutationName(agentName);
-        assert(result.mutations[createAgentSessionMutationName] === undefined, `Schema already has a mutation with the name "${createAgentSessionMutationName}"`);
+        assertValidMutationName(createAgentSessionMutationName);
         result.mutations[createAgentSessionMutationName] = {
             description: `Create a session for the ${agentName} agent`,
-            shape: createAgentSessionResponse.shapeName,
+            shape: agentSessionShapeName,
             resolver: {
                 name: 'ai:createAgentSession',
                 agentName
             }
         };
+        const inspectAgentQueryName = getInspectAgentQueryName(agentName);
+        assertValidQueryName(inspectAgentQueryName);
+        result.queries[inspectAgentQueryName] = {
+            description: `Inspect the ${agentName} agent`,
+            args: inspectAgentArgs.schema,
+            shape: inspectAgentResponseShapeName,
+            resolver: {
+                name: 'ai:inspectAgent',
+                agentName
+            }
+        };
+        result.mutations[getSendAgentFeedbackMutationName(agentName)] ||= {
+            description: `Send feedback for the ${agentName} agent`,
+            args: sendAgentFeedbackArgs.shapeName,
+            shape: 'boolean',
+            resolver: {
+                name: 'ai:sendAgentFeedback',
+                agentName
+            }
+        };
+        // This mutation can vary depending on the inputs defined, everything else is stable for the whole agent (for now)
         for (const inputConfig of agent.api.inputs) {
             if (inputConfig.type === 'mutation') {
                 const inputName = inputConfig.name;
                 const sendAgentMessageMutationName = getSendAgentMessageMutationName(inputName);
-                assert(result.mutations[sendAgentMessageMutationName] === undefined, `Schema already has a mutation with the name "${sendAgentMessageMutationName}"`);
+                assertValidMutationName(sendAgentMessageMutationName);
                 result.mutations[sendAgentMessageMutationName] = {
                     description: agent.description,
                     args: {
                         type: 'object',
                         extends: [
                             {
-                                ...sendAgentMessageArgs.propertySchema,
+                                ...sendAgentMessageArgs.shapeSchema,
                                 required: agent.protection?.enabled
-                                    ? [...sendAgentMessageArgs.propertySchema.required, 'token']
-                                    : sendAgentMessageArgs.propertySchema.required
+                                    ? [...sendAgentMessageArgs.shapeSchema.required, 'token']
+                                    : sendAgentMessageArgs.shapeSchema.required
                             },
                             {
                                 '@ref': inputConfig.args
@@ -162,75 +230,8 @@ export function getAgentFeatures(agents) {
                         inputName
                     }
                 };
-                const agentMessageShapeName = getAgentMessageShapeName(inputName);
-                assert(result.shapes[agentMessageShapeName] === undefined, `Schema already has a shape with the name "${agentMessageShapeName}"`);
-                result.shapes[agentMessageShapeName] = {
-                    id: agentMessageShapeName,
-                    name: agentMessageShapeName,
-                    title: agentMessageShapeName,
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            ...getAgentMessageResponse.schema.properties,
-                            output: {
-                                '@ref': shape
-                            },
-                            input: {
-                                '@ref': inputConfig.args
-                            }
-                        },
-                        required: [...getAgentMessageResponse.schema.required],
-                        additionalProperties: false
-                    }
-                };
-                const getAgentMessageQueryName = getGetAgentMessageQueryName(inputName);
-                assert(result.queries[getAgentMessageQueryName] === undefined, `Schema already has a query with the name ${getAgentMessageQueryName}`);
-                result.queries[getAgentMessageQueryName] = {
-                    description: `Get a message for the ${agentName} agent`,
-                    shape: agentMessageShapeName,
-                    resolver: {
-                        name: 'ai:getAgentMessage',
-                        agentName
-                    },
-                    args: {
-                        ...getAgentMessageArgs.schema
-                    }
-                };
-                const abortAgentMessageMutationName = getAbortAgentMessageMutationName(inputName);
-                assert(result.mutations[abortAgentMessageMutationName] === undefined, `Schema already has a mutation with the name ${abortAgentMessageMutationName}`);
-                result.mutations[abortAgentMessageMutationName] = {
-                    description: `Abort a message for the ${agentName} agent`,
-                    shape: abortAgentMessageResponse.shapeName,
-                    resolver: {
-                        name: 'ai:abortAgentMessage',
-                        agentName
-                    },
-                    args: {
-                        ...getAgentMessageArgs.schema
-                    }
-                };
             }
         }
-        result.queries[getInspectAgentQueryName(agentName)] ||= {
-            description: `Inspect the ${agentName} agent`,
-            args: {
-                ...inspectAgentArgs.schema
-            },
-            shape: inspectAgentResponse.shapeName,
-            resolver: {
-                name: 'ai:inspectAgent',
-                agentName
-            }
-        };
-        result.mutations[getSendAgentFeedbackMutationName(agentName)] ||= {
-            description: `Send feedback for the ${agentName} agent`,
-            args: sendAgentFeedbackArgs.shapeName,
-            shape: 'boolean',
-            resolver: {
-                name: 'ai:sendAgentFeedback',
-                agentName
-            }
-        };
     }
     return result;
 }

package/dist/builtin-schema.js

@@ -3,10 +3,12 @@ import * as agentChatArgs from "./resolvers/ai/agent-chat-args.js";
 import * as agentChatPayload from "./resolvers/ai/agent-chat-payload.js";
 import * as agentChatResponse from "./resolvers/ai/agent-chat-response.js";
 import * as agentGenerateArgs from "./resolvers/ai/agent-generate-args.js";
+import * as agentMessageInput from "./resolvers/ai/agent-message-input.js";
+import * as agentMessageOutput from "./resolvers/ai/agent-message-output.js";
+import * as agentMessagePayload from "./resolvers/ai/agent-message-payload.js";
 import * as agentRunMode from "./resolvers/ai/agent-run-mode.js";
-import * as createAgentSessionResponse from "./resolvers/ai/create-agent-session-response.js";
+import * as agentSessionPayload from "./resolvers/ai/agent-session-payload.js";
 import * as embeddingSearchArgs from "./resolvers/ai/embedding-search.js";
-import * as inspectAgentResponse from "./resolvers/ai/inspect-agent-response.js";
 import * as sendAgentFeedbackArgs from "./resolvers/ai/send-agent-feedback-args.js";
 import * as asset from "./resolvers/takeshape/assets/asset.js";
 import * as assetImage from "./resolvers/takeshape/assets/asset-image.js";
@@ -222,7 +224,7 @@ const builtInShapes = {
         title: 'Chat Agent Response',
         id: agentChatResponse.shapeName,
         name: agentChatResponse.shapeName,
-        schema: agentChatResponse.schema
+        schema: agentChatResponse.createUserShapeSchema()
     },
     [agentChatPayload.shapeName]: {
         title: 'Chat Agent Payload',
@@ -230,29 +232,77 @@ const builtInShapes = {
         name: agentChatPayload.shapeName,
         schema: agentChatPayload.schema
     },
-    [inspectAgentResponse.shapeName]: {
-        title: 'Inspect Agent Response',
-        id: inspectAgentResponse.shapeName,
-        name: inspectAgentResponse.shapeName,
-        schema: inspectAgentResponse.schema
-    },
-    [createAgentSessionResponse.shapeName]: {
-        title: 'Create Agent Session Response',
-        id: createAgentSessionResponse.shapeName,
-        name: createAgentSessionResponse.shapeName,
-        schema: createAgentSessionResponse.schema
-    },
     [abortAgentMessageResponse.shapeName]: {
         title: 'Abort Agent Message Response',
         id: abortAgentMessageResponse.shapeName,
         name: abortAgentMessageResponse.shapeName,
-        schema: abortAgentMessageResponse.schema
+        schema: abortAgentMessageResponse.shapeSchema
     },
     [sendAgentFeedbackArgs.shapeName]: {
         title: 'Send Agent Feedback Args',
         id: sendAgentFeedbackArgs.shapeName,
         name: sendAgentFeedbackArgs.shapeName,
         schema: sendAgentFeedbackArgs.schema
+    },
+    [agentMessageInput.stringInputSchema.title]: {
+        title: agentMessageInput.stringInputSchema.title,
+        id: agentMessageInput.stringInputSchema.title,
+        name: agentMessageInput.stringInputSchema.title,
+        schema: agentMessageInput.stringInputSchema
+    },
+    [agentMessageInput.unknownInputSchema.title]: {
+        title: agentMessageInput.unknownInputSchema.title,
+        id: agentMessageInput.unknownInputSchema.title,
+        name: agentMessageInput.unknownInputSchema.title,
+        schema: agentMessageInput.unknownInputSchema
+    },
+    [agentMessageInput.shapeName]: {
+        title: agentMessageInput.shapeSchema.title,
+        id: agentMessageInput.shapeSchema.title,
+        name: agentMessageInput.shapeSchema.title,
+        schema: agentMessageInput.shapeSchema
+    },
+    [agentMessageOutput.generateStateOutputSchema.title]: {
+        title: agentMessageOutput.generateStateOutputSchema.title,
+        id: agentMessageOutput.generateStateOutputSchema.title,
+        name: agentMessageOutput.generateStateOutputSchema.title,
+        schema: agentMessageOutput.generateStateOutputSchema
+    },
+    [agentMessageOutput.graphQLStateOutputSchema.title]: {
+        title: agentMessageOutput.graphQLStateOutputSchema.title,
+        id: agentMessageOutput.graphQLStateOutputSchema.title,
+        name: agentMessageOutput.graphQLStateOutputSchema.title,
+        schema: agentMessageOutput.graphQLStateOutputSchema
+    },
+    [agentMessageOutput.chatStateOutputSchema.title]: {
+        title: agentMessageOutput.chatStateOutputSchema.title,
+        id: agentMessageOutput.chatStateOutputSchema.title,
+        name: agentMessageOutput.chatStateOutputSchema.title,
+        schema: agentMessageOutput.chatStateOutputSchema
+    },
+    [agentMessageOutput.unknownStateOutputSchema.title]: {
+        title: agentMessageOutput.unknownStateOutputSchema.title,
+        id: agentMessageOutput.unknownStateOutputSchema.title,
+        name: agentMessageOutput.unknownStateOutputSchema.title,
+        schema: agentMessageOutput.unknownStateOutputSchema
+    },
+    [agentMessageOutput.shapeName]: {
+        title: agentMessageOutput.shapeSchema.title,
+        id: agentMessageOutput.shapeSchema.title,
+        name: agentMessageOutput.shapeSchema.title,
+        schema: agentMessageOutput.shapeSchema
+    },
+    [agentSessionPayload.shapeName]: {
+        title: agentSessionPayload.shapeSchema.title,
+        id: agentSessionPayload.shapeSchema.title,
+        name: agentSessionPayload.shapeSchema.title,
+        schema: agentSessionPayload.shapeSchema
+    },
+    [agentMessagePayload.shapeName]: {
+        title: agentMessagePayload.shapeSchema.title,
+        id: agentMessagePayload.shapeSchema.title,
+        name: agentMessagePayload.shapeSchema.title,
+        schema: agentMessagePayload.shapeSchema
     }
 };
 const staticSiteShapes = {

package/dist/layers/refs.d.ts

@@ -77,7 +77,7 @@ export declare function refItemToShape(shapes: ShapeMapV4_0_0, refItem: RefItem)
 /**
  * Helper fn to omit `ref` props from the target schema, and then extend it with the source schema.
  */
-export declare const omitRefAndExtend: (targetSchema: PropertySchemaV4_0_0, sourceSchema: PropertySchemaV4_0_0) => import("lodash").Omit<PropertySchemaV4_0_0, "$ref" | "@ref"> & PropertySchemaV4_0_0;
+export declare const omitRefAndExtend: (targetSchema: PropertySchemaV4_0_0, sourceSchema: PropertySchemaV4_0_0) => import("lodash").Omit<PropertySchemaV4_0_0, "@ref" | "$ref"> & PropertySchemaV4_0_0;
 /**
  * If there is a $ref, this will insert a content schema from the top level
  * in place of the reference.

package/dist/models/project-schema.d.ts

@@ -1,10 +1,10 @@
 import type { ProjectSchemaJSON, PropertySchema } from '../project-schema/index.ts';
 import type { ServiceLayers } from '../types/types.ts';
-import type { Agent, ProjectSchema, Query, Shape } from './types.ts';
+import type { Agent, GetShapeOptions, ProjectSchema, Query, Shape } from './types.ts';
 export declare class ProjectSchemaImpl implements ProjectSchema {
     #private;
     constructor(projectSchemaJson: ProjectSchemaJSON, layers: ServiceLayers);
-    getShape(rawShapeRef: string): Shape | undefined;
+    getShape(rawShapeRef: string, options?: GetShapeOptions): Shape | undefined;
     getQuery(rawQueryRef: string): Query | undefined;
     ensureQuery(ref: string): Query;
     getLocalQueries(): Query[];

package/dist/models/project-schema.js

@@ -1,4 +1,5 @@
 import { getAgent, getAgentMap } from "../agents.js";
+import { allBuiltInShapes } from '../builtin-schema.js';
 import { dereferenceObjectSchema, dereferenceSchema, getQuery, normalizePropertyRef, normalizeRefExpression, parsePropertyRef, parseRef, refItemToNamespacedShapeName } from "../refs.js";
 import { getShape } from "../util/shapes.js";
 import { createAgent } from "./agent.js";
@@ -17,14 +18,17 @@ export class ProjectSchemaImpl {
         this.#queryCache = new Map();
         this.#agentCache = new Map();
     }
-    getShape(rawShapeRef) {
+    getShape(rawShapeRef, options) {
         const shapeRef = normalizeRefExpression(this.#projectSchemaJson, rawShapeRef);
         let shape = this.#shapeCache.get(shapeRef);
         if (!shape) {
             const refItem = parseRef(this.#projectSchemaJson, rawShapeRef);
             if (refItem) {
                 const namespacedName = refItemToNamespacedShapeName(this.#projectSchemaJson, refItem);
-                const shapeJson = getShape(this.#projectSchemaJson, namespacedName);
+                let shapeJson = getShape(this.#projectSchemaJson, namespacedName);
+                if (!shapeJson && options?.includeAllBuiltIns) {
+                    shapeJson = getShape({ shapes: allBuiltInShapes }, namespacedName);
+                }
                 if (shapeJson) {
                     shape = createShape(this, refItem, shapeJson);
                     this.#shapeCache.set(shapeRef, shape);
@@ -32,7 +36,7 @@ export class ProjectSchemaImpl {
                 else if (refItem.layerId !== 'local') {
                     const layerSchema = this.#layers[refItem.layerId]?.schema;
                     if (layerSchema) {
-                        const shapeJson = getShape(layerSchema, namespacedName);
+                        shapeJson = getShape(layerSchema, namespacedName);
                         if (shapeJson) {
                             shape = createShape(this, refItem, shapeJson);
                             this.#shapeCache.set(shapeRef, shape);

package/dist/models/types.d.ts

@@ -1,7 +1,10 @@
 import type { AgentJSON, ObjectSchema, ProjectSchemaJSON, PropertySchema, QueryJSON, ShapeJSON } from '../project-schema/index.ts';
 import type { RefItem } from '../refs.ts';
+export interface GetShapeOptions {
+    includeAllBuiltIns?: boolean;
+}
 export interface ProjectSchema {
-    getShape(shapeRef: string): Shape | undefined;
+    getShape(shapeRef: string, options?: GetShapeOptions): Shape | undefined;
     getQuery(queryRef: string): Query | undefined;
     getLocalQueries(): Query[];
     getLocalMutations(): Query[];

package/dist/project-schema/latest.d.ts

@@ -1843,6 +1843,12 @@ export interface ShapeSchemaExtends {
  * via the `definition` "shapeSchemaOneOf".
  */
 export interface ShapeSchemaOneOf {
+    title?: string;
+    description?: string;
+    discriminator?: {
+        propertyName: string;
+        [k: string]: any;
+    };
     oneOf: ObjectOrRefArray;
 }
 /**

package/dist/project-schema/v3.59.0.d.ts

@@ -1843,6 +1843,12 @@ export interface ShapeSchemaExtendsV3_59_0 {
  * via the `definition` "shapeSchemaOneOf".
  */
 export interface ShapeSchemaOneOfV3_59_0 {
+    title?: string;
+    description?: string;
+    discriminator?: {
+        propertyName: string;
+        [k: string]: any;
+    };
     oneOf: ObjectOrRefArrayV3_59_0;
 }
 /**

package/dist/refs.d.ts

@@ -153,7 +153,7 @@ export declare function refSchemaToShapeSchemaPath(context: ServicesContext, ref
 /**
  * Helper fn to omit `ref` props from the target schema, and then extend it with the source schema.
  */
-export declare const omitRefAndExtend: (targetSchema: PropertySchema, sourceSchema: PropertySchema) => import("lodash").Omit<PropertySchema, "$ref" | "@ref"> & PropertySchema;
+export declare const omitRefAndExtend: (targetSchema: PropertySchema, sourceSchema: PropertySchema) => import("lodash").Omit<PropertySchema, "@ref" | "$ref"> & PropertySchema;
 /**
  * If there is a $ref, this will insert a property schema from the top level
  * in place of the reference.

package/dist/resolvers/ai/abort-agent-message-response.d.ts

@@ -19,8 +19,21 @@ export declare const schema: {
     readonly additionalProperties: false;
 };
 export type AbortAgentMessageResponse = FromSchema<typeof schema>;
-export declare const validate: import("ajv").ValidateFunction<{
-    aborted?: {
-        messageId: string;
-    } | undefined;
-}>;
+export declare const shapeSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly aborted: {
+            readonly type: "object";
+            readonly properties: {
+                readonly messageId: {
+                    readonly type: "string";
+                    readonly description: "The ID of the aborted deferred message";
+                };
+            };
+            readonly required: ["messageId"];
+            readonly additionalProperties: false;
+        };
+    };
+    readonly required: [];
+    readonly additionalProperties: false;
+};

package/dist/resolvers/ai/abort-agent-message-response.js

@@ -1,6 +1,4 @@
-import { createTypedValidator } from '@takeshape/json-schema';
-import { AI_AGENT_ABORT_AGENT_MESSAGE_RESPONSE_SHAPE_NAME } from "./constants.js";
-export const shapeName = AI_AGENT_ABORT_AGENT_MESSAGE_RESPONSE_SHAPE_NAME;
+export const shapeName = 'TSAbortAgentMessageResponse';
 export const schema = {
     type: 'object',
     properties: {
@@ -16,4 +14,6 @@ export const schema = {
     required: [],
     additionalProperties: false
 };
-export const validate = createTypedValidator(schema);
+export const shapeSchema = {
+    ...schema
+};

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

@@ -1,6 +1,5 @@
 import { createTypedValidator } from '@takeshape/json-schema';
-import { AI_AGENT_CHAT_ARGS_SHAPE_NAME } from "./constants.js";
-export const shapeName = AI_AGENT_CHAT_ARGS_SHAPE_NAME;
+export const shapeName = 'TSChatArgs';
 export const schema = {
     type: 'object',
     properties: {

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

@@ -1,6 +1,5 @@
 import { createTypedValidator } from '@takeshape/json-schema';
-import { AI_AGENT_CHAT_PAYLOAD_SHAPE_NAME } from "./constants.js";
-export const shapeName = AI_AGENT_CHAT_PAYLOAD_SHAPE_NAME;
+export const shapeName = 'TSChatPayload';
 export const schema = {
     type: 'object',
     properties: {