@4djs/assistant 0.1.5 → 0.1.7

package/dist/labels.d.ts

@@ -111,6 +111,8 @@ export declare const DEFAULT_ASSISTANT_LABELS: {
     readonly "emptyState.capabilities.query": "Query";
     readonly "emptyState.capabilities.mutate": "Mutate";
     readonly "activity.trace": "Trace";
+    readonly "activity.copyTrace": "Copy trace";
+    readonly "activity.copyTraceSuccess": "Trace copied";
     readonly "activity.live": "Live";
     readonly "activity.arguments": "Arguments";
     readonly "activity.running": "Running…";

package/dist/labels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../src/labels.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8J3B,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,wBAAwB,CAAC;AAEtE,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;AAEhE,6DAA6D;AAC7D,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAE/D,eAAO,MAAM,oBAAoB,EAE5B,iBAAiB,EAAE,CAAC;AAEzB,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GACtC,MAAM,CAIR;AAED,wBAAgB,sBAAsB,CACpC,SAAS,CAAC,EAAE,uBAAuB,GAClC,eAAe,CAEjB"}
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../src/labels.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgK3B,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,wBAAwB,CAAC;AAEtE,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;AAEhE,6DAA6D;AAC7D,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAE/D,eAAO,MAAM,oBAAoB,EAE5B,iBAAiB,EAAE,CAAC;AAEzB,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GACtC,MAAM,CAIR;AAED,wBAAgB,sBAAsB,CACpC,SAAS,CAAC,EAAE,uBAAuB,GAClC,eAAe,CAEjB"}

package/dist/react/components/chat/ChatActivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ChatActivity.d.ts","sourceRoot":"","sources":["../../../../src/react/components/chat/ChatActivity.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,gBAAgB,EAKtB,MAAM,gCAAgC,CAAC;AAOxC,UAAU,iBAAiB;IACzB,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAyOD,wBAAgB,YAAY,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,iBAAiB,sCAgEnE"}
+{"version":3,"file":"ChatActivity.d.ts","sourceRoot":"","sources":["../../../../src/react/components/chat/ChatActivity.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,gBAAgB,EAMtB,MAAM,gCAAgC,CAAC;AAOxC,UAAU,iBAAiB;IACzB,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAkRD,wBAAgB,YAAY,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,iBAAiB,sCAiEnE"}

package/dist/styles.css

@@ -808,6 +808,30 @@
   font-variant-numeric: tabular-nums;
 }
 
+.assistant-activity__copy {
+  display: inline-flex;
+  flex-shrink: 0;
+  align-items: center;
+  justify-content: center;
+  width: 1.625rem;
+  height: 1.625rem;
+  border: 1px solid var(--border-default);
+  border-radius: calc(var(--radius-base) - 2px);
+  background: var(--surface-panel);
+  color: var(--text-chat-secondary);
+  cursor: pointer;
+  transition:
+    background 150ms ease,
+    border-color 150ms ease,
+    color 150ms ease;
+}
+
+.assistant-activity__copy:hover {
+  border-color: var(--border-default-medium);
+  background: var(--overlay-subtle);
+  color: var(--text-heading);
+}
+
 .assistant-activity__steps {
   list-style: none;
   margin: 0;

package/dist/tools/index.d.ts

@@ -1,4 +1,6 @@
 export { type AssistantToolHandler, type AssistantToolRegistry, connectExternalTools, createAssistantToolRegistry, resolveAssistantToolHooks, } from "../core/tool-registry.js";
 export type { DatastoreQueryInput, DatastoreToolsAdapter, } from "./datastore.js";
 export { registerDatastoreTools } from "./datastore.js";
+export { type MethodArgumentSchema, type MethodArgumentType, METHOD_ARGUMENT_TYPES, argumentsToParamsSchema, buildParamsPropertySchema, isMethodArgumentSchema, methodArgumentItemJsonSchema, methodArgumentsEditorJsonSchema, migrateParamsSchemaToArguments, parseMethodArguments, sanitizeMethodArgumentForType, } from "./method-arguments.js";
+export { type BuildMethodToolHandlersOptions, type MethodToolCatalog, type MethodToolInvokeFn, type MethodToolInvokeInput, type MethodToolMetadata, type MethodToolMetadataSchema, type MethodToolScope, buildMethodToolHandlers, buildMethodToolName, } from "./method-tools.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,oBAAoB,EACpB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,oBAAoB,EACpB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,qBAAqB,EACrB,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACtB,4BAA4B,EAC5B,+BAA+B,EAC/B,8BAA8B,EAC9B,oBAAoB,EACpB,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EACpB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,mBAAmB,CAAC"}

package/dist/tools/index.js

@@ -43,6 +43,9 @@ class AssistantToolRegistryImpl {
   has(name) {
     return this.entries.has(name);
   }
+  listRegisteredToolNames() {
+    return [...this.entries.keys()];
+  }
   async listTools() {
     return [...this.entries.values()].filter((entry) => entry.active).map((entry) => entry.handler.definition);
   }
@@ -240,9 +243,416 @@ function registerDatastoreTools(registry, adapter) {
   }
   return registry;
 }
+// src/tools/method-arguments.ts
+var METHOD_ARGUMENT_TYPES = [
+  "string",
+  "integer",
+  "number",
+  "boolean",
+  "object",
+  "array"
+];
+var DESCRIPTION_PROPERTY = {
+  type: "string",
+  description: "Human-readable description for the assistant"
+};
+var ENUM_PROPERTY = {
+  type: "array",
+  description: "Allowed values for this parameter",
+  items: {}
+};
+var EXAMPLES_PROPERTY = {
+  type: "array",
+  description: "Example values for this parameter",
+  items: {}
+};
+var JSON_SCHEMA_FRAGMENT = {
+  type: "object",
+  description: "Nested JSON Schema",
+  additionalProperties: true
+};
+function argumentTypeBranch(type, typeProperties) {
+  return {
+    type: "object",
+    required: ["type"],
+    properties: {
+      type: { const: type },
+      description: DESCRIPTION_PROPERTY,
+      enum: ENUM_PROPERTY,
+      examples: EXAMPLES_PROPERTY,
+      ...typeProperties
+    },
+    additionalProperties: true
+  };
+}
+var methodArgumentItemJsonSchema = {
+  oneOf: [
+    argumentTypeBranch("string", {
+      minLength: {
+        type: "integer",
+        minimum: 0,
+        description: "Minimum string length"
+      },
+      maxLength: {
+        type: "integer",
+        minimum: 0,
+        description: "Maximum string length"
+      },
+      pattern: {
+        type: "string",
+        description: "Regular expression the string must match"
+      }
+    }),
+    argumentTypeBranch("integer", {
+      minimum: {
+        type: "number",
+        description: "Minimum value (inclusive)"
+      },
+      maximum: {
+        type: "number",
+        description: "Maximum value (inclusive)"
+      }
+    }),
+    argumentTypeBranch("number", {
+      minimum: {
+        type: "number",
+        description: "Minimum value (inclusive)"
+      },
+      maximum: {
+        type: "number",
+        description: "Maximum value (inclusive)"
+      }
+    }),
+    argumentTypeBranch("boolean", {}),
+    argumentTypeBranch("object", {
+      properties: {
+        type: "object",
+        description: "Property schemas keyed by name",
+        additionalProperties: JSON_SCHEMA_FRAGMENT
+      },
+      required: {
+        type: "array",
+        description: "Required property names",
+        items: { type: "string" }
+      },
+      additionalProperties: {
+        description: "Whether properties not listed in properties are allowed",
+        type: ["boolean", "object"]
+      }
+    }),
+    argumentTypeBranch("array", {
+      items: {
+        ...JSON_SCHEMA_FRAGMENT,
+        description: "JSON Schema describing each array element"
+      },
+      minItems: {
+        type: "integer",
+        minimum: 0,
+        description: "Minimum number of items"
+      },
+      maxItems: {
+        type: "integer",
+        minimum: 0,
+        description: "Maximum number of items"
+      }
+    })
+  ]
+};
+var methodArgumentsEditorJsonSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "array",
+  description: "Positional method parameters passed to the assistant tool",
+  items: methodArgumentItemJsonSchema
+};
+function sanitizeMethodArgumentForType(arg, nextType) {
+  const base = {
+    type: nextType,
+    ...arg.description !== undefined ? { description: arg.description } : {},
+    ...arg.enum !== undefined ? { enum: arg.enum } : {},
+    ...arg.examples !== undefined ? { examples: arg.examples } : {}
+  };
+  switch (nextType) {
+    case "string":
+      return {
+        ...base,
+        ...arg.minLength !== undefined ? { minLength: arg.minLength } : {},
+        ...arg.maxLength !== undefined ? { maxLength: arg.maxLength } : {},
+        ...typeof arg.pattern === "string" ? { pattern: arg.pattern } : {}
+      };
+    case "integer":
+    case "number":
+      return {
+        ...base,
+        ...arg.minimum !== undefined ? { minimum: arg.minimum } : {},
+        ...arg.maximum !== undefined ? { maximum: arg.maximum } : {}
+      };
+    case "boolean":
+      return base;
+    case "object":
+      return {
+        ...base,
+        ...arg.properties !== undefined ? { properties: arg.properties } : {},
+        ...arg.required !== undefined ? { required: arg.required } : {},
+        ...arg.additionalProperties !== undefined ? { additionalProperties: arg.additionalProperties } : {}
+      };
+    case "array":
+      return {
+        ...base,
+        ...arg.items !== undefined ? { items: arg.items } : {},
+        ...arg.minItems !== undefined ? { minItems: arg.minItems } : {},
+        ...arg.maxItems !== undefined ? { maxItems: arg.maxItems } : {}
+      };
+  }
+}
+function isMethodArgumentSchema(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const type = value.type;
+  return type === "string" || type === "integer" || type === "number" || type === "boolean" || type === "object" || type === "array";
+}
+function parseMethodArguments(value) {
+  if (!Array.isArray(value))
+    return;
+  const parsed = value.filter(isMethodArgumentSchema);
+  return parsed.length > 0 ? parsed : undefined;
+}
+function migrateParamsSchemaToArguments(paramsSchema) {
+  if (!paramsSchema)
+    return;
+  if (paramsSchema.type === "array" && Array.isArray(paramsSchema.prefixItems)) {
+    return parseMethodArguments(paramsSchema.prefixItems);
+  }
+  return;
+}
+function argumentsToParamsSchema(args) {
+  if (args.length === 0) {
+    return { type: "array", items: {} };
+  }
+  return {
+    type: "array",
+    prefixItems: args,
+    minItems: args.length,
+    maxItems: args.length
+  };
+}
+function buildParamsPropertySchema(args) {
+  if (!args?.length) {
+    return {
+      type: "array",
+      description: "Function parameters as a JSON array (positional)",
+      items: {}
+    };
+  }
+  return {
+    description: "Function parameters as a JSON array (positional)",
+    ...argumentsToParamsSchema(args)
+  };
+}
+// src/tools/method-tools.ts
+function normalizeApplyTo(applyTo) {
+  switch (applyTo) {
+    case "entity":
+      return "entity";
+    case "entitySelection":
+      return "entitySelection";
+    case "dataClass":
+      return "dataclass";
+    default:
+      return "dataclass";
+  }
+}
+function buildMethodToolName(input) {
+  switch (input.scope) {
+    case "entity":
+      return `@dataclass/${input.dataClass}/Entity/${input.methodName}`;
+    case "entitySelection":
+      return `@dataclass/${input.dataClass}/EntitySet/${input.methodName}`;
+    case "singleton":
+      return `@datastore/singletons/${input.singletonName}/${input.methodName}`;
+    case "catalog":
+      return `@datastore/methods/${input.methodName}`;
+    default:
+      return `@dataclass/${input.dataClass}/${input.methodName}`;
+  }
+}
+function buildInputSchema(candidate) {
+  const properties = {
+    params: buildParamsPropertySchema(candidate.metadata?.arguments)
+  };
+  const required = [];
+  if (candidate.scope === "entity") {
+    properties.key = {
+      type: "string",
+      description: "Entity primary key"
+    };
+    required.push("key");
+  }
+  if (candidate.scope === "entitySelection") {
+    properties.filter = {
+      type: "string",
+      description: "4D filter expression for the entity selection"
+    };
+    properties.entitySetId = {
+      type: "string",
+      description: "Existing entity set ID (alternative to filter)"
+    };
+    properties.orderby = {
+      type: "string",
+      description: "Order by expression for the entity selection"
+    };
+  }
+  if (candidate.metadata?.arguments?.length) {
+    required.push("params");
+  }
+  return {
+    type: "object",
+    properties,
+    required: required.length > 0 ? required : undefined,
+    additionalProperties: false
+  };
+}
+function buildDescription(candidate) {
+  if (candidate.metadata?.description?.trim()) {
+    return candidate.metadata.description.trim();
+  }
+  const signature = candidate.paramsText?.trim();
+  const target = candidate.scope === "singleton" ? `${candidate.singletonName}.${candidate.methodName}` : candidate.scope === "catalog" ? candidate.methodName : `${candidate.dataClass}.${candidate.methodName}`;
+  const httpMethod = candidate.allowedOnHTTPGET ? "GET or POST" : "POST";
+  if (signature) {
+    return `Call ${target} (${httpMethod}). Signature: ${signature}`;
+  }
+  return `Call ${target} (${httpMethod})`;
+}
+function defaultIsMethodExposed(method) {
+  if (method.exposed === true)
+    return true;
+  if (method.exposed === false)
+    return false;
+  const scope = typeof method.scope === "string" ? method.scope.trim() : "";
+  if (scope === "publicOnServer")
+    return false;
+  if (scope === "public")
+    return true;
+  return false;
+}
+function collectCandidates(options) {
+  const { catalog, metadata } = options;
+  const isExposed = options.isMethodExposed ?? defaultIsMethodExposed;
+  const candidates = [];
+  for (const dataClass of catalog.dataClasses ?? []) {
+    for (const method of dataClass.methods ?? []) {
+      if (!method.name || !isExposed(method))
+        continue;
+      const scope = normalizeApplyTo(method.applyTo);
+      candidates.push({
+        toolName: buildMethodToolName({
+          scope,
+          dataClass: dataClass.name,
+          methodName: method.name
+        }),
+        scope,
+        dataClass: dataClass.name,
+        methodName: method.name,
+        allowedOnHTTPGET: method.allowedOnHTTPGET,
+        paramsText: method.paramsText,
+        metadata: metadata?.dataClasses?.[dataClass.name]?.methods?.[method.name]
+      });
+    }
+  }
+  for (const singleton of catalog.singletons ?? []) {
+    for (const method of singleton.methods ?? []) {
+      if (!method.name || !isExposed(method))
+        continue;
+      candidates.push({
+        toolName: buildMethodToolName({
+          scope: "singleton",
+          singletonName: singleton.name,
+          methodName: method.name
+        }),
+        scope: "singleton",
+        singletonName: singleton.name,
+        methodName: method.name,
+        allowedOnHTTPGET: method.allowedOnHTTPGET,
+        paramsText: method.paramsText,
+        metadata: metadata?.singletons?.[singleton.name]?.methods?.[method.name]
+      });
+    }
+  }
+  for (const method of catalog.methods ?? []) {
+    if (!method.name || !isExposed(method))
+      continue;
+    candidates.push({
+      toolName: buildMethodToolName({
+        scope: "catalog",
+        methodName: method.name
+      }),
+      scope: "catalog",
+      methodName: method.name,
+      allowedOnHTTPGET: method.allowedOnHTTPGET,
+      paramsText: method.paramsText,
+      metadata: metadata?.catalogMethods?.[method.name]
+    });
+  }
+  return candidates;
+}
+function buildMethodToolHandlers(options) {
+  const candidates = collectCandidates(options);
+  const usedNames = new Set;
+  return candidates.map((candidate) => {
+    let toolName = candidate.toolName;
+    if (usedNames.has(toolName)) {
+      toolName = `${candidate.scope}_${toolName}`;
+    }
+    usedNames.add(toolName);
+    return {
+      definition: {
+        name: toolName,
+        description: buildDescription(candidate),
+        inputSchema: buildInputSchema(candidate)
+      },
+      invoke: async (args) => {
+        const input = args;
+        if (candidate.scope === "entity" && input.key === undefined) {
+          return toolResultErr("key is required for entity methods");
+        }
+        if (candidate.scope === "entitySelection" && !input.filter && !input.entitySetId) {
+          return toolResultErr("filter or entitySetId is required for entity selection methods");
+        }
+        try {
+          const result = await options.invoke({
+            scope: candidate.scope,
+            dataClass: candidate.dataClass,
+            singletonName: candidate.singletonName,
+            methodName: candidate.methodName,
+            params: input.params ?? [],
+            key: input.key,
+            filter: input.filter,
+            orderby: input.orderby,
+            entitySetId: input.entitySetId,
+            allowedOnHTTPGET: candidate.allowedOnHTTPGET
+          });
+          return toolResultOk(result);
+        } catch (error) {
+          return toolResultErr(error instanceof Error ? error.message : String(error));
+        }
+      }
+    };
+  });
+}
 export {
+  sanitizeMethodArgumentForType,
   resolveAssistantToolHooks,
   registerDatastoreTools,
+  parseMethodArguments,
+  migrateParamsSchemaToArguments,
+  methodArgumentsEditorJsonSchema,
+  methodArgumentItemJsonSchema,
+  isMethodArgumentSchema,
   createAssistantToolRegistry,
-  connectExternalTools
+  connectExternalTools,
+  buildParamsPropertySchema,
+  buildMethodToolName,
+  buildMethodToolHandlers,
+  argumentsToParamsSchema,
+  METHOD_ARGUMENT_TYPES
 };

package/dist/tools/method-arguments.d.ts

@@ -0,0 +1,35 @@
+export type MethodArgumentType = "string" | "integer" | "number" | "boolean" | "object" | "array";
+export declare const METHOD_ARGUMENT_TYPES: readonly MethodArgumentType[];
+/** JSON Schema for a single positional method parameter (type-specific fields). */
+export declare const methodArgumentItemJsonSchema: Record<string, unknown>;
+/** JSON Schema for editing method `arguments` arrays in metadata. */
+export declare const methodArgumentsEditorJsonSchema: Record<string, unknown>;
+export interface MethodArgumentSchema {
+    type: MethodArgumentType;
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: unknown[];
+    examples?: unknown[];
+    properties?: Record<string, unknown>;
+    required?: string[];
+    additionalProperties?: boolean | Record<string, unknown>;
+    items?: Record<string, unknown>;
+    minItems?: number;
+    maxItems?: number;
+    [key: string]: unknown;
+}
+/** Keep only fields valid for the target JSON Schema type. */
+export declare function sanitizeMethodArgumentForType(arg: MethodArgumentSchema, nextType: MethodArgumentType): MethodArgumentSchema;
+export declare function isMethodArgumentSchema(value: unknown): value is MethodArgumentSchema;
+export declare function parseMethodArguments(value: unknown): MethodArgumentSchema[] | undefined;
+/** Migrate legacy paramsSchema with prefixItems to arguments[]. */
+export declare function migrateParamsSchemaToArguments(paramsSchema: Record<string, unknown> | undefined): MethodArgumentSchema[] | undefined;
+/** Positional arguments → JSON Schema array with prefixItems (4D REST params body). */
+export declare function argumentsToParamsSchema(args: MethodArgumentSchema[]): Record<string, unknown>;
+/** Build the `params` property schema for a method tool inputSchema. */
+export declare function buildParamsPropertySchema(args: MethodArgumentSchema[] | undefined): Record<string, unknown>;
+//# sourceMappingURL=method-arguments.d.ts.map

package/dist/tools/method-arguments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-arguments.d.ts","sourceRoot":"","sources":["../../src/tools/method-arguments.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAC1B,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,CAAC;AAEZ,eAAO,MAAM,qBAAqB,EAAE,SAAS,kBAAkB,EAOrD,CAAC;AA2CX,mFAAmF;AACnF,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAwEhE,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,+BAA+B,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAKnE,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,kBAAkB,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,8DAA8D;AAC9D,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,oBAAoB,EACzB,QAAQ,EAAE,kBAAkB,GAC3B,oBAAoB,CA0CtB;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAWpF;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,EAAE,GAAG,SAAS,CAIvF;AAED,mEAAmE;AACnE,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAChD,oBAAoB,EAAE,GAAG,SAAS,CAMpC;AAED,uFAAuF;AACvF,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,oBAAoB,EAAE,GAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB;AAED,wEAAwE;AACxE,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,oBAAoB,EAAE,GAAG,SAAS,GACvC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB"}

package/dist/tools/method-tools.d.ts

@@ -0,0 +1,62 @@
+import type { AssistantToolHandler } from "../core/tool-registry.js";
+import { type MethodArgumentSchema } from "./method-arguments.js";
+export type MethodToolScope = "dataclass" | "entity" | "entitySelection" | "singleton" | "catalog";
+export interface MethodToolCatalogMethod {
+    name: string;
+    applyTo?: string;
+    exposed?: boolean;
+    allowedOnHTTPGET?: boolean;
+    scope?: string;
+    paramsText?: string;
+}
+export interface MethodToolCatalog {
+    dataClasses?: Array<{
+        name: string;
+        methods?: MethodToolCatalogMethod[];
+    }>;
+    singletons?: Array<{
+        name: string;
+        methods?: MethodToolCatalogMethod[];
+    }>;
+    methods?: MethodToolCatalogMethod[];
+}
+export interface MethodToolMetadata {
+    description?: string;
+    arguments?: MethodArgumentSchema[];
+}
+export interface MethodToolMetadataSchema {
+    dataClasses?: Record<string, {
+        methods?: Record<string, MethodToolMetadata>;
+    }>;
+    singletons?: Record<string, {
+        methods?: Record<string, MethodToolMetadata>;
+    }>;
+    catalogMethods?: Record<string, MethodToolMetadata>;
+}
+export interface MethodToolInvokeInput {
+    scope: MethodToolScope;
+    dataClass?: string;
+    singletonName?: string;
+    methodName: string;
+    params?: unknown[];
+    key?: string | number;
+    filter?: string;
+    orderby?: string;
+    entitySetId?: string;
+    allowedOnHTTPGET?: boolean;
+}
+export type MethodToolInvokeFn = (input: MethodToolInvokeInput) => Promise<unknown>;
+export interface BuildMethodToolHandlersOptions {
+    catalog: MethodToolCatalog;
+    metadata: MethodToolMetadataSchema | null | undefined;
+    invoke: MethodToolInvokeFn;
+    isMethodExposed?: (method: MethodToolCatalogMethod) => boolean;
+}
+export declare function buildMethodToolName(input: {
+    scope: MethodToolScope;
+    dataClass?: string;
+    singletonName?: string;
+    methodName: string;
+}): string;
+export declare function buildMethodToolHandlers(options: BuildMethodToolHandlersOptions): AssistantToolHandler[];
+//# sourceMappingURL=method-tools.d.ts.map

package/dist/tools/method-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-tools.d.ts","sourceRoot":"","sources":["../../src/tools/method-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,uBAAuB,CAAC;AAE/B,MAAM,MAAM,eAAe,GACvB,WAAW,GACX,QAAQ,GACR,iBAAiB,GACjB,WAAW,GACX,SAAS,CAAC;AAEd,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,KAAK,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,uBAAuB,EAAE,CAAC;KACrC,CAAC,CAAC;IACH,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,uBAAuB,EAAE,CAAC;KACrC,CAAC,CAAC;IACH,OAAO,CAAC,EAAE,uBAAuB,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,CAAC,EAAE,MAAM,CAClB,MAAM,EACN;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;KAAE,CACjD,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CACjB,MAAM,EACN;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;KAAE,CACjD,CAAC;IACF,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,eAAe,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,MAAM,kBAAkB,GAAG,CAC/B,KAAK,EAAE,qBAAqB,KACzB,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,wBAAwB,GAAG,IAAI,GAAG,SAAS,CAAC;IACtD,MAAM,EAAE,kBAAkB,CAAC;IAC3B,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,OAAO,CAAC;CAChE;AA0BD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,KAAK,EAAE,eAAe,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,MAAM,CAaT;AAuID,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,8BAA8B,GACtC,oBAAoB,EAAE,CA8DxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4djs/assistant",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "types": "./dist/react/index.d.ts",
   "files": [