@takeshape/schema 11.98.6 → 11.99.2

package/dist/agents.d.ts

@@ -1,14 +1,13 @@
-import type { AgentAPI, AgentAPIArgument, AgentJSON, Args, GuardJSON, ProjectSchemaJSON } from './project-schema/index.ts';
+import type { AgentJSON, AgentMap, GuardJSON, GuardMap, ProjectSchemaJSON, QueryJSON } from './project-schema/index.ts';
+export declare const START_AGENT_EXECUTION = "START";
 /**
  * Special transition destination ID for agent transitions that end the agent execution.
  */
-export declare const END_AGENT_EXECUTION = "endAgentExecution";
+export declare const END_AGENT_EXECUTION = "END";
 /**
  * Special history strategy ID that indicates the history should be cleared.
  */
 export declare const CLEAR_HISTORY_STRATEGY_ID = "clearHistory";
-export declare const BUILT_IN_CHAT_ARGS: AgentAPIArgument[];
-export declare const BUILT_IN_CHAT_ARG_NAMES: string[];
 export type AgentEndTransition = {
     type: 'done' | 'progress';
     originStateId: string;
@@ -16,18 +15,24 @@ export type AgentEndTransition = {
 export declare const getAgentEndTransitions: (agent: AgentJSON, includeSuspend?: boolean) => AgentEndTransition[];
 export declare const getAgentEndStates: (agent: AgentJSON, includeSuspend?: boolean) => Set<string>;
 export declare const getInspectAgentSessionQueryName: (agentName: string) => string;
-export declare const removeBuiltInArgs: (args: AgentAPIArgument[]) => AgentAPIArgument[];
-export declare function getAgentApiArgs(api: AgentAPI): AgentAPIArgument[];
-export declare const createArgs: (agent: AgentJSON) => Args | undefined;
+export declare function getAgentQueries(agents: AgentMap): Pick<ProjectSchemaJSON, 'queries' | 'mutations'>;
+export declare function isValidAgentMutation(projectSchema: ProjectSchemaJSON, name: string): boolean;
 export declare function addAiQueries(projectSchema: ProjectSchemaJSON): ProjectSchemaJSON;
 /**
  * Where guards live in the schema.
  */
 export declare const GUARDS_SCHEMA_PATH: readonly ["ai-experimental", "guards"];
+export declare const AGENTS_SCHEMA_PATH: readonly ["ai-experimental", "agents"];
 /**
  * Check if a guard is enabled.
  */
 export declare const isGuardEnabled: (guard: GuardJSON | undefined) => boolean;
+export declare function getGuardMap(schema: ProjectSchemaJSON): GuardMap | undefined;
+export declare function getGuards(schema: ProjectSchemaJSON): (GuardJSON & {
+    id: string;
+})[];
+export declare function setGuardMap<S extends Partial<ProjectSchemaJSON>>(schema: S, guards: GuardMap): S;
+export declare function setGuard<S extends Partial<ProjectSchemaJSON>>(schema: S, id: string, guard: GuardJSON): S;
 /**
  * Get a guard configuration from the project schema.
  */
@@ -36,3 +41,12 @@ export declare function getGuardConfig(schema: ProjectSchemaJSON, guardId: strin
  * Get a guard configuration from the project schema, but only if it is enabled.
  */
 export declare function getEnabledGuardConfig(schema: ProjectSchemaJSON, guardId: string): GuardJSON | undefined;
+export declare function getAgentMap(projectSchema: Pick<ProjectSchemaJSON, 'ai-experimental'>): AgentMap | undefined;
+export declare function getAgents(projectSchema: Pick<ProjectSchemaJSON, 'ai-experimental'>): (AgentJSON & {
+    name: string;
+})[] | undefined;
+export declare function setAgentMap<S extends Partial<ProjectSchemaJSON>>(projectSchema: S, agents: AgentMap): S;
+export declare function setAgent<S extends Partial<ProjectSchemaJSON>>(projectSchema: S, name: string, agent: AgentJSON): S;
+export declare function getAgent(projectSchema: ProjectSchemaJSON, name: string): AgentJSON | undefined;
+export declare function ensureAgent(projectSchema: ProjectSchemaJSON, name: string): AgentJSON;
+export declare function isAgentQuery(query: QueryJSON, agentName: string): boolean;

package/dist/agents.js

@@ -1,35 +1,22 @@
+import set from 'lodash/fp/set.js';
 import get from 'lodash/get.js';
 import uniq from 'lodash/uniq.js';
-import uniqBy from 'lodash/uniqBy.js';
 import upperFirst from 'lodash/upperFirst.js';
+export const START_AGENT_EXECUTION = 'START';
 /**
  * Special transition destination ID for agent transitions that end the agent execution.
  */
-export const END_AGENT_EXECUTION = 'endAgentExecution';
+export const END_AGENT_EXECUTION = 'END';
 /**
  * Special history strategy ID that indicates the history should be cleared.
  */
 export const CLEAR_HISTORY_STRATEGY_ID = 'clearHistory';
-export const BUILT_IN_CHAT_ARGS = [
-    {
-        argName: 'input',
-        argDescription: 'Input text for the agent',
-        argType: 'string',
-        required: true
-    },
-    {
-        argName: 'sessionId',
-        argDescription: 'Session ID to continue existing session with this agent',
-        argType: 'sessionId'
-    }
-];
-export const BUILT_IN_CHAT_ARG_NAMES = BUILT_IN_CHAT_ARGS.map((arg) => arg.argName);
 const transitionCanEnd = (transition, includeSuspend = false) => {
     if (!transition || transition.length === 0) {
         return true;
     }
     for (const step of transition) {
-        if (includeSuspend && step.suspend) {
+        if (includeSuspend && step.type === 'suspend') {
             return true;
         }
         if (step.destination === END_AGENT_EXECUTION) {
@@ -59,41 +46,10 @@ export const getAgentEndStates = (agent, includeSuspend = false) => {
 export const getInspectAgentSessionQueryName = (agentName) => {
     return `inspect${upperFirst(agentName)}`;
 };
-export const removeBuiltInArgs = (args) => {
-    return args.filter((arg) => !BUILT_IN_CHAT_ARG_NAMES.includes(arg.argName));
-};
-export function getAgentApiArgs(api) {
-    let apiArguments = uniqBy(api.arguments ?? [], (arg) => arg.argName);
-    if (api.type === 'chat') {
-        apiArguments = removeBuiltInArgs(apiArguments).concat(BUILT_IN_CHAT_ARGS);
-    }
-    return apiArguments;
-}
-export const createArgs = (agent) => {
-    const apiArguments = getAgentApiArgs(agent.api);
-    return apiArguments.length > 0
-        ? {
-            type: 'object',
-            properties: apiArguments.reduce((acc, argument) => {
-                acc[argument.argName] = {
-                    type: argument.argType === 'sessionId' ? 'string' : argument.argType,
-                    description: argument.argDescription
-                };
-                return acc;
-            }, {}),
-            required: apiArguments.filter((arg) => arg.required).map((arg) => arg.argName)
-        }
-        : undefined;
-};
-export function addAiQueries(projectSchema) {
-    const agents = projectSchema['ai-experimental']?.agents;
-    if (!agents) {
-        return projectSchema;
-    }
-    const newSchema = {
-        ...projectSchema,
-        queries: { ...projectSchema.queries },
-        mutations: { ...projectSchema.mutations }
+export function getAgentQueries(agents) {
+    const result = {
+        queries: {},
+        mutations: {}
     };
     for (const [agentName, agent] of Object.entries(agents)) {
         // Get valid return types based on states that could possibly be the end state
@@ -111,20 +67,25 @@ export function addAiQueries(projectSchema) {
             return 'JSON';
         }));
         const shape = returnTypes.length === 0 ? 'string' : returnTypes.length === 1 ? returnTypes[0] : 'JSON';
-        if (newSchema.mutations[agentName] !== undefined) {
-            throw new Error(`Schema already has a mutation with the name ${agentName}`);
-        }
-        newSchema.mutations[agentName] = {
-            description: agent.description,
-            args: createArgs(agent),
-            shape,
-            resolver: {
-                name: 'ai:runAgent',
-                agentName
+        for (const inputConfig of agent.api.inputs) {
+            if (inputConfig.type === 'mutation') {
+                const mutationName = inputConfig.name;
+                if (result.mutations[mutationName] !== undefined) {
+                    throw new Error(`Schema already has a mutation with the name "${mutationName}"`);
+                }
+                result.mutations[mutationName] = {
+                    description: agent.description,
+                    args: inputConfig.args,
+                    shape,
+                    resolver: {
+                        name: 'ai:runAgent',
+                        agentName
+                    }
+                };
             }
-        };
+        }
         if (shape === 'TSChatResponse') {
-            newSchema.queries[getInspectAgentSessionQueryName(agentName)] ||= {
+            result.queries[getInspectAgentSessionQueryName(agentName)] ||= {
                 description: `Inspect a session for the ${agentName} agent`,
                 args: {
                     type: 'object',
@@ -143,18 +104,60 @@ export function addAiQueries(projectSchema) {
             };
         }
     }
-    return newSchema;
+    return result;
+}
+export function isValidAgentMutation(projectSchema, name) {
+    for (const agent of Object.values(getAgentMap(projectSchema) ?? {})) {
+        for (const input of agent.api.inputs) {
+            if (input.type === 'mutation' && input.name === name) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function addAiQueries(projectSchema) {
+    const agents = getAgentMap(projectSchema);
+    if (!agents) {
+        return projectSchema;
+    }
+    const aiQueries = getAgentQueries(agents);
+    return {
+        ...projectSchema,
+        queries: {
+            ...projectSchema.queries,
+            ...aiQueries.queries
+        },
+        mutations: {
+            ...projectSchema.mutations,
+            ...aiQueries.mutations
+        }
+    };
 }
 /**
  * Where guards live in the schema.
  */
 export const GUARDS_SCHEMA_PATH = ['ai-experimental', 'guards'];
+export const AGENTS_SCHEMA_PATH = ['ai-experimental', 'agents'];
 /**
  * Check if a guard is enabled.
  */
 export const isGuardEnabled = (guard) => {
     return Boolean(guard && guard.enabled !== false);
 };
+export function getGuardMap(schema) {
+    return schema['ai-experimental']?.guards;
+}
+export function getGuards(schema) {
+    const guards = getGuardMap(schema);
+    return guards ? Object.entries(guards).map(([id, guard]) => ({ id, ...guard })) : [];
+}
+export function setGuardMap(schema, guards) {
+    return set(GUARDS_SCHEMA_PATH, guards, schema);
+}
+export function setGuard(schema, id, guard) {
+    return set([...GUARDS_SCHEMA_PATH, id], guard, schema);
+}
 /**
  * Get a guard configuration from the project schema.
  */
@@ -170,3 +173,33 @@ export function getEnabledGuardConfig(schema, guardId) {
         return config;
     }
 }
+export function getAgentMap(projectSchema) {
+    return projectSchema['ai-experimental']?.agents;
+}
+export function getAgents(projectSchema) {
+    const agentMap = getAgentMap(projectSchema);
+    return agentMap && Object.entries(agentMap).map(([name, agent]) => ({ name, ...agent }));
+}
+export function setAgentMap(projectSchema, agents) {
+    return set(AGENTS_SCHEMA_PATH, agents, projectSchema);
+}
+export function setAgent(projectSchema, name, agent) {
+    return set([...AGENTS_SCHEMA_PATH, name], agent, projectSchema);
+}
+export function getAgent(projectSchema, name) {
+    return getAgentMap(projectSchema)?.[name];
+}
+export function ensureAgent(projectSchema, name) {
+    const agent = getAgent(projectSchema, name);
+    if (!agent) {
+        throw new Error(`Agent "${name}" not found`);
+    }
+    return agent;
+}
+export function isAgentQuery(query, agentName) {
+    const resolver = query.resolver;
+    if ('agentName' in resolver) {
+        return resolver.agentName === agentName;
+    }
+    return false;
+}

package/dist/builtin-schema.js

@@ -310,6 +310,18 @@ export const builtInShapes = {
             }
         }
     },
+    TSGenerateArgs: {
+        id: 'TSGenerateArgs',
+        name: 'TSGenerateArgs',
+        title: 'Generate Args',
+        schema: {
+            type: 'object',
+            properties: {
+                input: { type: 'string' }
+            },
+            required: ['input']
+        }
+    },
     TSChatArgs: {
         id: 'TSChatArgs',
         name: 'TSChatArgs',

package/dist/index.d.ts

@@ -11,8 +11,10 @@ export * from './get-is-leaf.ts';
 export * from './interfaces.ts';
 export * from './migration/index.ts';
 export type { ProjectSchemaUpdate } from './migration/types.ts';
+export { AGENTS_UPDATE_KEY, GUARDS_UPDATE_KEY, MCP_TOOLS_UPDATE_KEY } from './migration/types.ts';
 export * from './mocks.ts';
 export * from './models/runtime-schema.ts';
+export * from './models/user-schema.ts';
 export * from './patterns.ts';
 export * from './project-schema/index.ts';
 export * from './project-schema/migrate.ts';

package/dist/index.js

@@ -9,8 +9,10 @@ export * from "./flatten-templates.js";
 export * from "./get-is-leaf.js";
 export * from "./interfaces.js";
 export * from "./migration/index.js";
+export { AGENTS_UPDATE_KEY, GUARDS_UPDATE_KEY, MCP_TOOLS_UPDATE_KEY } from "./migration/types.js";
 export * from "./mocks.js";
 export * from "./models/runtime-schema.js";
+export * from "./models/user-schema.js";
 export * from "./patterns.js";
 export * from "./project-schema/index.js";
 export * from "./project-schema/migrate.js";

package/dist/migration/types.d.ts

@@ -5,13 +5,16 @@ export type ProjectSchemaMigrationContext = {
     encryptFn: EncryptFn;
     decryptFn: SafeDecryptFn;
 };
+export declare const AGENTS_UPDATE_KEY = "ai-experimental.agents";
+export declare const GUARDS_UPDATE_KEY = "ai-experimental.guards";
+export declare const MCP_TOOLS_UPDATE_KEY = "ai-experimental.mcp.tools";
 export type ProjectSchemaUpdate = {
     queries?: Record<string, QueryJSON | null>;
     mutations?: Record<string, QueryJSON | null>;
     shapes?: Record<string, ShapeJSON | null>;
-    'ai-experimental.agents'?: Record<string, AgentJSON | null>;
-    'ai-experimental.guards'?: Record<string, GuardJSON | null>;
-    'ai-experimental.mcp.tools'?: Record<string, ToolJSON | null>;
+    [AGENTS_UPDATE_KEY]?: Record<string, AgentJSON | null>;
+    [GUARDS_UPDATE_KEY]?: Record<string, GuardJSON | null>;
+    [MCP_TOOLS_UPDATE_KEY]?: Record<string, ToolJSON | null>;
     forms?: Record<string, FormConfig | null>;
     workflows?: Record<string, Workflow | null>;
     services?: Record<string, ServiceConfigJSON | null>;

package/dist/migration/types.js

@@ -1 +1,3 @@
-export {};
+export const AGENTS_UPDATE_KEY = 'ai-experimental.agents';
+export const GUARDS_UPDATE_KEY = 'ai-experimental.guards';
+export const MCP_TOOLS_UPDATE_KEY = 'ai-experimental.mcp.tools';

package/dist/models/agent.d.ts

@@ -0,0 +1,3 @@
+import type { AgentJSON } from '../project-schema/latest.ts';
+import type { Agent, ProjectSchema } from './types.ts';
+export declare function createAgent(parent: ProjectSchema, name: string, agent: AgentJSON): Agent;

package/dist/models/agent.js

@@ -0,0 +1,29 @@
+import { isAgentQuery } from "../agents.js";
+function queryPredicate(agentName) {
+    return (query) => isAgentQuery(query.json, agentName);
+}
+class AgentImpl {
+    #schema;
+    #agentName;
+    #agent;
+    constructor(parent, name, agent) {
+        this.#schema = parent;
+        this.#agentName = name;
+        this.#agent = agent;
+    }
+    get name() {
+        return this.#agentName;
+    }
+    getMutations() {
+        return this.#schema.getLocalMutations().filter(queryPredicate(this.name));
+    }
+    getQueries() {
+        return this.#schema.getLocalQueries().filter(queryPredicate(this.name));
+    }
+    get json() {
+        return this.#agent;
+    }
+}
+export function createAgent(parent, name, agent) {
+    return new AgentImpl(parent, name, agent);
+}

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

@@ -0,0 +1,17 @@
+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';
+export declare class ProjectSchemaImpl implements ProjectSchema {
+    #private;
+    constructor(projectSchemaJson: ProjectSchemaJSON, layers: ServiceLayers);
+    getShape(rawShapeRef: string): Shape | undefined;
+    getQuery(rawQueryRef: string): Query | undefined;
+    ensureQuery(ref: string): Query;
+    getLocalQueries(): Query[];
+    getLocalMutations(): Query[];
+    getAgents(): Agent[];
+    ensureAgent(name: string): Agent;
+    getAgent(name: string): Agent | undefined;
+    dereferenceSchema(propertySchema: PropertySchema): PropertySchema;
+    get json(): ProjectSchemaJSON;
+}

package/dist/models/project-schema.js

@@ -0,0 +1,112 @@
+import { getAgent, getAgentMap } from "../agents.js";
+import { dereferenceSchema, getQuery, normalizePropertyRef, normalizeRefExpression, parsePropertyRef, parseRef, refItemToNamespacedShapeName } from "../refs.js";
+import { getShape } from "../util/shapes.js";
+import { createAgent } from "./agent.js";
+import { createQuery } from './query.js';
+import { createShape } from './shape.js';
+export class ProjectSchemaImpl {
+    #projectSchemaJson;
+    #layers;
+    #shapeCache;
+    #queryCache;
+    #agentCache;
+    constructor(projectSchemaJson, layers) {
+        this.#projectSchemaJson = projectSchemaJson;
+        this.#layers = layers;
+        this.#shapeCache = new Map();
+        this.#queryCache = new Map();
+        this.#agentCache = new Map();
+    }
+    getShape(rawShapeRef) {
+        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);
+                if (shapeJson) {
+                    shape = createShape(this, refItem, shapeJson);
+                    this.#shapeCache.set(shapeRef, shape);
+                }
+                else if (refItem.layerId !== 'local') {
+                    const layerSchema = this.#layers[refItem.layerId]?.schema;
+                    if (layerSchema) {
+                        const shapeJson = getShape(layerSchema, namespacedName);
+                        if (shapeJson) {
+                            shape = createShape(this, refItem, shapeJson);
+                            this.#shapeCache.set(shapeRef, shape);
+                        }
+                    }
+                }
+            }
+        }
+        return shape;
+    }
+    getQuery(rawQueryRef) {
+        const queryRef = normalizePropertyRef(rawQueryRef);
+        let query = this.#queryCache.get(queryRef);
+        if (!query) {
+            const queryEntry = getQuery(this.#projectSchemaJson, queryRef);
+            if (queryEntry) {
+                query = createQuery(this, queryEntry);
+                this.#queryCache.set(queryRef, query);
+            }
+            else {
+                const parsedRef = parsePropertyRef(queryRef);
+                if (parsedRef && parsedRef.layerId !== 'local') {
+                    const layerSchema = this.#layers[parsedRef.layerId]?.schema;
+                    if (layerSchema) {
+                        const queryEntry = getQuery(layerSchema, parsedRef.propertyName);
+                        if (queryEntry) {
+                            query = createQuery(this, { ...queryEntry, ref: parsedRef });
+                            this.#queryCache.set(queryRef, query);
+                        }
+                    }
+                }
+            }
+        }
+        return query;
+    }
+    ensureQuery(ref) {
+        const query = this.getQuery(ref);
+        if (!query) {
+            throw new Error(`Query "${ref}" not found`);
+        }
+        return query;
+    }
+    getLocalQueries() {
+        return Object.keys(this.#projectSchemaJson.queries).map((queryName) => this.ensureQuery(`Query.${queryName}`));
+    }
+    getLocalMutations() {
+        return Object.keys(this.#projectSchemaJson.mutations).map((queryName) => this.ensureQuery(`Mutation.${queryName}`));
+    }
+    getAgents() {
+        const agents = getAgentMap(this.#projectSchemaJson);
+        return agents ? Object.keys(agents).map((name) => this.ensureAgent(name)) : [];
+    }
+    ensureAgent(name) {
+        const agent = this.getAgent(name);
+        if (!agent) {
+            throw new Error(`Agent "${name}" not found`);
+        }
+        return agent;
+    }
+    getAgent(name) {
+        let agent = this.#agentCache.get(name);
+        if (!agent) {
+            const agentJson = getAgent(this.#projectSchemaJson, name);
+            if (agentJson) {
+                agent = createAgent(this, name, agentJson);
+                this.#agentCache.set(name, agent);
+            }
+        }
+        return agent;
+    }
+    dereferenceSchema(propertySchema) {
+        return dereferenceSchema(this.#projectSchemaJson, propertySchema);
+    }
+    get json() {
+        return this.#projectSchemaJson;
+    }
+}

package/dist/models/query.d.ts

@@ -1,9 +1,3 @@
-import type { ObjectSchema } from '../project-schema/latest.ts';
 import { type QueryEntry } from '../refs.ts';
-import type { ReferenceResolver } from './types.ts';
-export declare class Query {
-    #private;
-    constructor(parent: ReferenceResolver, entry: QueryEntry);
-    get ref(): string;
-    get argsSchema(): ObjectSchema | undefined;
-}
+import type { ProjectSchema, Query } from './types.ts';
+export declare function createQuery(parent: ProjectSchema, entry: QueryEntry): Query;

package/dist/models/query.js

@@ -1,11 +1,11 @@
 import { serializePropertyRef } from "../refs.js";
-export class Query {
-    #refResolver;
+class QueryImpl {
+    #schema;
     #name;
     #query;
     #ref;
     constructor(parent, entry) {
-        this.#refResolver = parent;
+        this.#schema = parent;
         this.#name = entry.name;
         this.#query = entry.query;
         this.#ref = entry.ref;
@@ -19,8 +19,20 @@ export class Query {
             if (typeof args === 'object') {
                 return args;
             }
-            return this.#refResolver.getShape(args)?.getObjectSchema();
+            return this.#schema.getShape(args)?.getObjectSchema();
         }
         return undefined;
     }
+    get type() {
+        return this.#ref.shapeName === 'Mutation' ? 'mutation' : 'query';
+    }
+    get name() {
+        return this.#name;
+    }
+    get json() {
+        return this.#query;
+    }
+}
+export function createQuery(parent, entry) {
+    return new QueryImpl(parent, entry);
 }

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

@@ -1,13 +1,9 @@
 import type { ProjectSchemaJSON } from '../project-schema/index.ts';
 import type { ServiceLayers } from '../types/types.ts';
-import { Query } from './query.js';
-import { Shape } from './shape.js';
-export declare class RuntimeSchema {
-    #private;
+import { ProjectSchemaImpl } from './project-schema.ts';
+export declare class RuntimeSchema extends ProjectSchemaImpl {
     private constructor();
     static buildSchema(userSchema: ProjectSchemaJSON, layers: ServiceLayers): RuntimeSchema;
+    static safeBuildSchema(userSchema: ProjectSchemaJSON, layers: ServiceLayers): RuntimeSchema | undefined;
     static fromJson(runtimeSchema: ProjectSchemaJSON, layers: ServiceLayers): RuntimeSchema;
-    getQuery(ref: string): Query | undefined;
-    getShape(ref: string): Shape | undefined;
-    get json(): ProjectSchemaJSON;
 }