@kortexya/reasoninglayer 1.25.0 → 1.26.0

package/dist/index.d.ts

@@ -109,7 +109,7 @@ type JsonValue$1 = string | number | boolean | null | JsonValue$1[] | object;
  * This is the single source of truth for the version constant.
  * The `scripts/release.sh` script updates this value alongside `package.json`.
  */
-declare const SDK_VERSION = "1.25.0";
+declare const SDK_VERSION = "1.26.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -2532,8 +2532,17 @@ interface BeliefDto$1 {
      */
     sort_id?: string | null;
 }
-/** Binary operator for expressions */
-type BinaryOperatorDto$1 = "Add" | "Subtract" | "Multiply" | "Divide";
+/**
+ * Binary operator for expressions.
+ *
+ * The full algebra the domain's `BinaryOperator` carries, not a subset of it.
+ * Four arithmetic operators were declared here while the engine had fourteen,
+ * and OSFQL `DERIVE` builds function bodies with every one of them
+ * (`osfql/executor.rs`, `ir_expression_to_function_expr`) — so a definition
+ * created that way could not be expressed in this shape, and a read that
+ * answered in this shape had to either drop it or lie about it (#235).
+ */
+type BinaryOperatorDto$1 = "Add" | "Subtract" | "Multiply" | "Divide" | "Modulo" | "LessThan" | "LessThanOrEqual" | "GreaterThan" | "GreaterThanOrEqual" | "Equal" | "NotEqual" | "And" | "Or";
 /** Request to bind a sort to a SQL table. */
 interface BindSortRequest$1 {
     /** Column mappings: feature name to column spec. */
@@ -5574,6 +5583,22 @@ interface CondResponse$1 {
     condition_succeeded: boolean;
     success: boolean;
 }
+/**
+ * One `WHEN cond THEN value` branch of a conditional expression.
+ *
+ * The domain carries these as an unnamed `(Expression, Expression)` pair.
+ * A two-element JSON array would round-trip just as well and read as nothing
+ * at all, so the wire shape names both halves.
+ */
+interface ConditionalBranchDto$1 {
+    /**
+     * The value of the whole conditional when this is the first branch whose
+     * condition is `true`.
+     */
+    then: ExpressionDto$1;
+    /** The condition, evaluated in source order against the clause's bindings. */
+    when: ExpressionDto$1;
+}
 interface ConditionalIndependenceRequest$1 {
     /** Conditioning set */
     conditioning_set: string[];
@@ -10694,7 +10719,16 @@ type ExpressionDto$1 = {
 } | {
     /** Arithmetic/logical expression */
     left: ExpressionDto$1;
-    /** Binary operator for expressions */
+    /**
+     * Binary operator for expressions.
+     *
+     * The full algebra the domain's `BinaryOperator` carries, not a subset of it.
+     * Four arithmetic operators were declared here while the engine had fourteen,
+     * and OSFQL `DERIVE` builds function bodies with every one of them
+     * (`osfql/executor.rs`, `ir_expression_to_function_expr`) — so a definition
+     * created that way could not be expressed in this shape, and a read that
+     * answered in this shape had to either drop it or lie about it (#235).
+     */
     op: BinaryOperatorDto$1;
     /** Arithmetic/logical expression */
     right: ExpressionDto$1;
@@ -10703,6 +10737,16 @@ type ExpressionDto$1 = {
     arguments: ExpressionDto$1[];
     function_name: string;
     type: "FunctionCall";
+} | {
+    /** Unary operator for expressions. */
+    op: UnaryOperatorDto$1;
+    /** Arithmetic/logical expression */
+    operand: ExpressionDto$1;
+    type: "UnaryOp";
+} | {
+    branches: ConditionalBranchDto$1[];
+    default?: null | ExpressionDto$1;
+    type: "Conditional";
 };
 /** Extended agent state DTO with full cognitive state. */
 interface ExtendedAgentStateDto$1 {
@@ -12150,6 +12194,14 @@ type FunctionCallersDisposition$1 = "refuse" | "orphan";
 interface FunctionClauseDto$1 {
     /** Function body - what to compute */
     body: FunctionBodyDto$1;
+    /**
+     * The clause's guard, if it has one.
+     *
+     * Omitted rather than serialized as `null` when absent, so what
+     * `GET /api/v1/functions/{name}` emits is byte-for-byte a body
+     * `register` and `PUT` accept (#235). An explicit `"guard": null` is
+     * still accepted on the way in.
+     */
     guard?: null | GuardDto;
     parameters: PatternDto$1[];
 }
@@ -12165,6 +12217,26 @@ interface FunctionDraftDto$1 {
 }
 /** Execution kind for a registered function. */
 type FunctionKindDto$1 = "Classic" | "Neural";
+/**
+ * Why a registered function cannot be replaced, in the same terms the
+ * mutation route would answer with.
+ *
+ * Mirrors `RuleNotWithdrawableDto`: the read tells a client what the write
+ * would say, so a UI can present the function without offering an edit that
+ * is going to be refused.
+ */
+interface FunctionNotReplaceableDto$1 {
+    /**
+     * The stable machine-readable discriminator `PUT` and `DELETE` carry —
+     * currently `function_plugin_owned`.
+     */
+    code: string;
+    /**
+     * The refusal in words, naming the lifecycle operation that DOES remove
+     * the function.
+     */
+    reason: string;
+}
 /**
  * Typed signature summary for a single registered function.
  *
@@ -13176,6 +13248,87 @@ interface GetFactsResponse$1 {
     /** List of facts */
     facts: PsiTermDto$1[];
 }
+/**
+ * Response of `GET /api/v1/functions/{name}` — the registered definition.
+ *
+ * # Why the clauses come back in the register shape
+ *
+ * `PUT /api/v1/functions/{name}` reports what it displaced — `previous`,
+ * `current`, `arity_changed`, every caller — and all of that describes the
+ * change AFTER it happened. Nothing let a caller see what they were about to
+ * overwrite, so a client editing one clause of a three-clause function had to
+ * re-author the other two from memory (#235).
+ *
+ * [`Self::clauses`] is therefore the exact payload
+ * `PUT /api/v1/functions/{name}` and `POST /api/v1/functions/register` accept:
+ * a read-modify-write is an edit, not a re-authoring, and needs no
+ * translation layer that could drop a body variant on the way through.
+ *
+ * # And why `clauses` is optional
+ *
+ * The clause shape is total over every construct the engine can currently
+ * build — that is what widening `BinaryOperatorDto` and `ExpressionDto` was
+ * for. It is NOT total over the domain's `Value`, which carries Ψ-terms,
+ * lists, geometries and more that no function producer emits.
+ *
+ * If one ever appears, the read declines to describe it rather than
+ * degrading it to `Uninstantiated`: `clauses` is absent,
+ * [`Self::unrepresentable`] names what stopped it, and the signature fields
+ * still answer. A wrong definition presented as a right one is the failure
+ * this route exists to prevent, and a `PUT` of it would destroy the real one.
+ */
+interface GetFunctionResponse$1 {
+    /**
+     * The number of named arguments it accepts.
+     * @min 0
+     */
+    arity: number;
+    /**
+     * Everything that calls this function, by the same scan `DELETE` refuses
+     * on and `PUT` reports.
+     *
+     * Read before offering an edit: a replacement that changes the arity
+     * keeps every one of these resolvable and makes every one of them wrong.
+     */
+    callers?: FunctionCallerDto[];
+    /**
+     * The pattern-matched clauses, tried in order — in the shape
+     * `register` and `PUT` accept.
+     *
+     * Absent only when the definition holds a construct this shape cannot
+     * express, in which case [`Self::unrepresentable`] says which.
+     */
+    clauses?: FunctionClauseDto$1[] | null;
+    /**
+     * Its stable id, as the registration reported it.
+     * @format uuid
+     */
+    function_id: string;
+    /** Whether it is classical or neural/fuzzy. */
+    kind: FunctionKindDto$1;
+    /** The function's name — the key `POST /functions/evaluate` takes. */
+    name: string;
+    /**
+     * When [`Self::replaceable`] is false, the refusal a `PUT` would produce
+     * — the same `code` and the same prose. Absent otherwise.
+     */
+    not_replaceable?: null | FunctionNotReplaceableDto$1;
+    /**
+     * Whether `PUT`/`DELETE` on this function will act rather than refuse.
+     *
+     * Read through the same admission the mutation routes run, so the read
+     * and the refusal cannot disagree. The engine stays the authority: a
+     * state change between this read and the write can still refuse.
+     */
+    replaceable: boolean;
+    /**
+     * What stopped the definition being expressed in the register shape.
+     *
+     * Absent — not empty — on the ordinary read. Present with `clauses`
+     * absent, never both.
+     */
+    unrepresentable?: string | null;
+}
 /** Request to read the fuzzy subsumption degree `sub ⊑· sup` */
 interface GetFuzzySubsumptionRequest {
     /**
@@ -30279,6 +30432,8 @@ interface UiAffinityDoc {
 }
 /** Complete hierarchy of UI component sorts */
 type UiSort$1 = "app" | "page" | "dashboard" | "grid" | "flex" | "stack" | "box" | "card" | "divider" | "spacer" | "navbar" | "sidebar" | "tabs" | "tab_panel" | "breadcrumbs" | "menu" | "menu_item" | "link" | "router" | "route" | "data_table" | "column" | "list" | "list_item" | "tree" | "tree_node" | "chart" | "stat" | "badge" | "avatar" | "icon" | "image" | "video" | "text" | "heading" | "paragraph" | "code" | "markdown" | "label" | "form" | "form_field" | "input" | "textarea" | "select" | "option" | "checkbox" | "radio" | "radio_group" | "toggle" | "slider" | "date_picker" | "time_picker" | "date_range_picker" | "file_upload" | "color_picker" | "autocomplete" | "search_input" | "button" | "button_group" | "icon_button" | "fab" | "dropdown_button" | "modal" | "dialog" | "drawer" | "popover" | "tooltip" | "toast" | "alert" | "progress" | "spinner" | "skeleton" | "accordion" | "accordion_item" | "collapsible" | "carousel" | "drag_drop_zone" | "draggable" | "drop_target" | "resizable" | "sortable_list" | "command_palette" | "wizard" | "wizard_step" | "timeline" | "timeline_item" | "kanban_board" | "kanban_column" | "kanban_card" | "calendar" | "rich_text_editor" | "conditional" | "for_each" | "show" | "suspense" | "error_boundary" | "portal" | "data_source" | "computed" | "state" | "effect" | "on_event" | "on_click" | "on_submit" | "on_change" | "sequence" | "navigate" | "api_call" | "set_state" | "show_toast" | "open_modal" | "close_modal" | "animate" | "transition" | "keyframes" | "auth_provider" | "protected_route" | "login_form" | "logout_button" | "user_profile" | "permission_gate" | "session_timeout" | "i18n_provider" | "trans" | "language_switcher" | "locale_date" | "locale_number" | "locale_currency" | "bidi" | "responsive" | "show_on_breakpoint" | "hide_on_breakpoint" | "container_query" | "aspect_ratio" | "theme_provider" | "theme_toggle" | "css_var" | "styled" | "color_scheme" | "screen_reader_only" | "skip_link" | "focus_trap" | "live_region" | "keyboard_nav" | "accessible_label" | "focus_ring" | "virtual_list" | "virtual_grid" | "virtual_table" | "infinite_scroll" | "lazy_load" | "code_split" | "prefetch" | "offline_indicator" | "sync_status" | "cache_control" | "background_sync" | "install_prompt" | "update_available" | "undo_provider" | "undo_button" | "redo_button" | "history_browser" | "snapshot" | "restore_point" | "hotkey" | "shortcut_hint" | "key_combo" | "shortcut_scope" | "global_search" | "search_results" | "search_highlight" | "search_filters" | "recent_searches" | "copy_button" | "paste_handler" | "share_button" | "qr_code" | "export_button" | "print_button" | "print_only" | "screen_only" | "pdf_preview" | "presence_indicator" | "cursor_overlay" | "typing_indicator" | "conflict_resolver" | "realtime_diff" | "notification_center" | "push_notification" | "inbox" | "unread_badge" | "notification_settings" | "debug_panel" | "state_inspector" | "perf_monitor" | "network_inspector" | "error_reporter" | "position" | "layer" | "overlay" | "fixed" | "sticky" | "form_state_provider" | "field_error" | "validation_schema" | "async_validator" | "cross_field_validation" | "pagination" | "cursor_pagination" | "load_more" | "page_size_selector" | "search_params" | "route_params" | "deep_link" | "url_state" | "query_binding" | "scroll_container" | "scroll_snap" | "scroll_lock" | "scroll_restore" | "scroll_to" | "scroll_spy" | "selection_provider" | "selectable" | "selection_actions" | "range_selection" | "gesture_handler" | "swipe_action" | "pinch_zoom" | "long_press" | "pan_gesture" | "multi_touch" | "file_download" | "file_preview" | "file_progress" | "file_browser" | "drop_zone" | "image_cropper" | "animation_controller" | "animation_timeline" | "spring" | "motion_value" | "animate_presence" | "stagger" | "focus_scope" | "focus_manager" | "auto_focus" | "restore_focus" | "merge_conflict" | "conflict_resolution" | "version_indicator" | "tenant_provider" | "tenant_switcher" | "tenant_branding" | "audit_log" | "activity_feed" | "change_history" | "feature_gate" | "feature_provider" | "beta_badge" | "experiment" | "variant" | "experiment_provider" | "analytics" | "page_view" | "click_tracker" | "event_tracker" | "rate_limit_indicator" | "maintenance_mode" | "system_status" | "scheduled_downtime" | "document_head" | "meta_tag" | "document_title" | "open_graph" | "structured_data" | "video_call" | "audio_call" | "screen_share" | "media_stream" | "camera_capture" | "audio_recorder" | "canvas2_d" | "web_g_l" | "drawing_canvas" | "signature_pad" | "geolocation" | "device_orientation" | "camera" | "barcode_scanner" | "local_storage_binding" | "session_storage_binding" | "indexed_db_binding";
+/** Unary operator for expressions. */
+type UnaryOperatorDto$1 = "Not" | "Negate";
 interface UncertainEdgeDto$1 {
     /** Possible directions */
     possible_directions: [string, string][];
@@ -56388,6 +56543,16 @@ declare class Functions<SecurityDataType = unknown> {
      * @secure
      */
     evaluateFunction: (data: EvaluateFunctionRequest$1, params?: RequestParams) => Promise<HttpResponse<EvaluateFunctionResponse$1, void>>;
+    /**
+     * @description # Why this route had to exist `/api/v1/functions` had five routes and none of them returned a definition: the listing answers summaries (`name`, `arity`, `clauses_count`, `kind`), and `GET /api/v1/functions/{name}` was a `405`. So `PUT` replaced a definition its caller could not see — a client fixing one clause of a three-clause function had to remember the other two or lose them, and the route made a partial edit look like a whole one (#235). # The clauses come back in the shape `PUT` takes [`GetFunctionResponse::clauses`] is the exact `clauses` payload `POST /functions/register` and `PUT /functions/{name}` accept, so a read-modify-write needs no translation layer that could drop a body variant on the way through. Making that true meant widening the request shape: `BinaryOperatorDto` carried four of the domain's thirteen operators and `ExpressionDto` was missing `UnaryOp` and `Conditional`, while OSFQL `DERIVE` builds function bodies with every one of them. A read in the old shape would have had to drop a `CASE WHEN` or lie about a `%`. # Reading is not changing A plugin-contributed function is refused by `DELETE` and `PUT` and **returned** by this route, with `replaceable: false` and the refusal the mutation would answer with. The listing already admits it exists; refusing to describe it would leave a client unable to show what the plugin contributed while still showing its name. The refusal is read from the same walk the mutation routes run, so the two cannot disagree. # Authorization Requires `X-Tenant-Id`. The function store is tenant-keyed, so another tenant's function is `404` rather than forbidden — saying anything else would confirm the name exists somewhere.
+     *
+     * @tags functions
+     * @name GetFunction
+     * @summary Read one registered function's definition.
+     * @request GET:/api/v1/functions/{name}
+     * @secure
+     */
+    getFunction: (name: string, params?: RequestParams) => Promise<HttpResponse<GetFunctionResponse$1, void>>;
     /**
      * @description This is the discovery counterpart to `register_function`/`evaluate_function`: it projects the tenant's slice of the function sub-lattice into a list of typed signatures (name + arity + clause count) without evaluating anything. The tenant is taken from the authenticated principal (never a body field), honouring the tenancy-scoping invariant.
      *
@@ -56422,8 +56587,33 @@ declare class Functions<SecurityDataType = unknown> {
 
 /**
  * Binary operator for expressions within function bodies.
+ *
+ * @remarks
+ * The whole algebra the engine carries, not the arithmetic corner of it. Four
+ * operators were declared here while the engine had thirteen, and OSFQL
+ * `DERIVE` builds function bodies with every one of them — so a definition
+ * created that way could not be expressed in this shape, and a read that
+ * answered in this shape had to drop it or lie about it (backend #235).
  */
-type BinaryOperatorDto = 'Add' | 'Subtract' | 'Multiply' | 'Divide';
+type BinaryOperatorDto = 'Add' | 'Subtract' | 'Multiply' | 'Divide' | 'Modulo' | 'LessThan' | 'LessThanOrEqual' | 'GreaterThan' | 'GreaterThanOrEqual' | 'Equal' | 'NotEqual' | 'And' | 'Or';
+/** Unary operator for expressions within function bodies. */
+type UnaryOperatorDto = 'Not' | 'Negate';
+/**
+ * One `WHEN cond THEN value` branch of a {@link ExpressionDto} `Conditional`.
+ *
+ * @remarks
+ * The engine carries these as an unnamed pair; the wire names both halves,
+ * because a two-element array round-trips as well and reads as nothing.
+ */
+interface ConditionalBranchDto {
+    /** The condition, evaluated in source order against the clause's bindings. */
+    when: ExpressionDto;
+    /**
+     * The value of the whole conditional when this is the first branch whose
+     * condition holds.
+     */
+    then: ExpressionDto;
+}
 /**
  * Value type for LIFE-style function literals.
  *
@@ -56467,6 +56657,16 @@ type ExpressionDto = {
     type: 'FunctionCall';
     functionName: string;
     arguments: ExpressionDto[];
+} | {
+    type: 'UnaryOp';
+    op: UnaryOperatorDto;
+    operand: ExpressionDto;
+} | {
+    type: 'Conditional';
+    /** Branches, tried in order; the first whose `when` holds supplies the value. */
+    branches: ConditionalBranchDto[];
+    /** The value when no branch holds. `null` when the conditional has none. */
+    default?: ExpressionDto | null;
 };
 /**
  * Function body — what a clause computes.
@@ -56817,6 +57017,112 @@ interface FunctionWithdrawalReport {
      */
     callersOrphaned: FunctionCaller[];
 }
+/**
+ * Why a registered function cannot be replaced, in the terms the mutation
+ * route would answer with.
+ *
+ * @remarks
+ * The read tells a client what the write would say, so a surface can present
+ * the function without offering an edit that is going to be refused.
+ */
+interface FunctionNotReplaceableDto {
+    /**
+     * The stable machine-readable discriminator `PUT` and `DELETE` carry —
+     * currently `'function_plugin_owned'`.
+     */
+    code: string;
+    /** The refusal in words, naming the lifecycle operation that DOES remove it. */
+    reason: string;
+}
+/**
+ * The signature half of a read definition — everything that answers whether or
+ * not the clauses could be expressed.
+ */
+interface FunctionDefinitionSignature {
+    /** The function's name — the key `POST /functions/evaluate` takes. */
+    name: string;
+    /** Its stable id, as the registration reported it. */
+    functionId: string;
+    /** The number of named arguments it accepts. */
+    arity: number;
+    /** Whether it is classical or neural/fuzzy. */
+    kind: FunctionKindDto;
+    /**
+     * Whether `PUT`/`DELETE` on this function will act rather than refuse.
+     *
+     * Read through the same admission the mutation routes run, so the read and
+     * the refusal cannot disagree. The engine stays the authority: a state
+     * change between this read and the write can still refuse.
+     */
+    replaceable: boolean;
+    /** The refusal a `PUT` would produce. Absent while `replaceable` is true. */
+    notReplaceable?: FunctionNotReplaceableDto;
+    /**
+     * Everything that calls this function, by the same scan `DELETE` refuses on
+     * and `PUT` reports.
+     *
+     * Read before offering an edit: a replacement that changes the arity keeps
+     * every one of these resolvable and makes every one of them wrong. Empty
+     * when nothing calls it.
+     */
+    callers: FunctionCaller[];
+}
+/**
+ * One registered function's definition, as `GET /functions/{name}` answers it.
+ *
+ * @remarks
+ * ## The clauses come back in the shape `PUT` takes
+ *
+ * The `clauses` of a readable definition are the exact payload
+ * {@link FunctionsClient.registerFunction} and
+ * {@link FunctionsClient.replaceFunction} accept, so a read-modify-write is an
+ * edit rather than a re-authoring. That is the point of the route: `PUT`
+ * replaces the WHOLE definition, so before it a client fixing one clause of a
+ * three-clause function had to remember the other two or lose them.
+ *
+ * ## Withheld is not empty, and the type says so
+ *
+ * `clauses: []` is a function with no clauses. A definition holding a
+ * construct the register shape cannot express comes back with no `clauses` at
+ * all and an `unrepresentable` reason — the engine declines to describe it
+ * rather than degrading it, because a `PUT` of a degraded read would destroy
+ * the real definition.
+ *
+ * The two are modelled as a union rather than two optional fields, so a client
+ * cannot read `clauses` without first ruling the withheld case out:
+ *
+ * ```typescript
+ * const definition = await client.functions.getFunction('scale');
+ * if (definition.clauses === undefined) {
+ *   console.warn(`cannot edit scale: ${definition.unrepresentable}`);
+ * } else {
+ *   await client.functions.replaceFunction('scale', {
+ *     arity: definition.arity,
+ *     clauses: [...definition.clauses, extraClause],
+ *   });
+ * }
+ * ```
+ *
+ * ## Reading is not changing
+ *
+ * A plugin-contributed function is refused by `DELETE`/`PUT` and RETURNED
+ * here, with `replaceable: false` and the refusal the mutation would give.
+ */
+type GetFunctionResponse = FunctionDefinitionSignature & ({
+    /**
+     * The pattern-matched clauses, tried in order — in the shape
+     * `register` and `PUT` accept.
+     */
+    clauses: FunctionClauseDto[];
+    unrepresentable?: undefined;
+} | {
+    clauses?: undefined;
+    /**
+     * What stopped the definition being expressed in the register shape.
+     * Present only with the clauses absent, never alongside them.
+     */
+    unrepresentable: string;
+});
 /** Result of replacing a registered function's definition. */
 interface ReplaceFunctionResponse {
     /** The function's name — unchanged by the replacement, by construction. */
@@ -56850,6 +57156,7 @@ interface ReplaceFunctionResponse {
 
 type functions_AuthoringClarificationQuestionDto = AuthoringClarificationQuestionDto;
 type functions_BinaryOperatorDto = BinaryOperatorDto;
+type functions_ConditionalBranchDto = ConditionalBranchDto;
 type functions_DraftFunctionRequest = DraftFunctionRequest;
 type functions_DraftFunctionResponse = DraftFunctionResponse;
 type functions_EvaluateFunctionRequest = EvaluateFunctionRequest;
@@ -56860,19 +57167,23 @@ type functions_FunctionCaller = FunctionCaller;
 type functions_FunctionCallerKind = FunctionCallerKind;
 type functions_FunctionCallersDisposition = FunctionCallersDisposition;
 type functions_FunctionClauseDto = FunctionClauseDto;
+type functions_FunctionDefinitionSignature = FunctionDefinitionSignature;
 type functions_FunctionDraftDto = FunctionDraftDto;
 type functions_FunctionGuardDto = FunctionGuardDto;
 type functions_FunctionKindDto = FunctionKindDto;
+type functions_FunctionNotReplaceableDto = FunctionNotReplaceableDto;
 type functions_FunctionSummaryDto = FunctionSummaryDto;
 type functions_FunctionValueDto = FunctionValueDto;
 type functions_FunctionWithdrawalReport = FunctionWithdrawalReport;
+type functions_GetFunctionResponse = GetFunctionResponse;
 type functions_ListFunctionsResponse = ListFunctionsResponse;
 type functions_PatternDto = PatternDto;
 type functions_RegisterFunctionRequest = RegisterFunctionRequest;
 type functions_RegisterFunctionResponse = RegisterFunctionResponse;
 type functions_ReplaceFunctionResponse = ReplaceFunctionResponse;
+type functions_UnaryOperatorDto = UnaryOperatorDto;
 declare namespace functions {
-  export type { functions_AuthoringClarificationQuestionDto as AuthoringClarificationQuestionDto, functions_BinaryOperatorDto as BinaryOperatorDto, functions_DraftFunctionRequest as DraftFunctionRequest, functions_DraftFunctionResponse as DraftFunctionResponse, functions_EvaluateFunctionRequest as EvaluateFunctionRequest, functions_EvaluateFunctionResponse as EvaluateFunctionResponse, functions_ExpressionDto as ExpressionDto, functions_FunctionBodyDto as FunctionBodyDto, functions_FunctionCaller as FunctionCaller, functions_FunctionCallerKind as FunctionCallerKind, functions_FunctionCallersDisposition as FunctionCallersDisposition, functions_FunctionClauseDto as FunctionClauseDto, functions_FunctionDraftDto as FunctionDraftDto, functions_FunctionGuardDto as FunctionGuardDto, functions_FunctionKindDto as FunctionKindDto, functions_FunctionSummaryDto as FunctionSummaryDto, functions_FunctionValueDto as FunctionValueDto, functions_FunctionWithdrawalReport as FunctionWithdrawalReport, functions_ListFunctionsResponse as ListFunctionsResponse, functions_PatternDto as PatternDto, functions_RegisterFunctionRequest as RegisterFunctionRequest, functions_RegisterFunctionResponse as RegisterFunctionResponse, functions_ReplaceFunctionResponse as ReplaceFunctionResponse };
+  export type { functions_AuthoringClarificationQuestionDto as AuthoringClarificationQuestionDto, functions_BinaryOperatorDto as BinaryOperatorDto, functions_ConditionalBranchDto as ConditionalBranchDto, functions_DraftFunctionRequest as DraftFunctionRequest, functions_DraftFunctionResponse as DraftFunctionResponse, functions_EvaluateFunctionRequest as EvaluateFunctionRequest, functions_EvaluateFunctionResponse as EvaluateFunctionResponse, functions_ExpressionDto as ExpressionDto, functions_FunctionBodyDto as FunctionBodyDto, functions_FunctionCaller as FunctionCaller, functions_FunctionCallerKind as FunctionCallerKind, functions_FunctionCallersDisposition as FunctionCallersDisposition, functions_FunctionClauseDto as FunctionClauseDto, functions_FunctionDefinitionSignature as FunctionDefinitionSignature, functions_FunctionDraftDto as FunctionDraftDto, functions_FunctionGuardDto as FunctionGuardDto, functions_FunctionKindDto as FunctionKindDto, functions_FunctionNotReplaceableDto as FunctionNotReplaceableDto, functions_FunctionSummaryDto as FunctionSummaryDto, functions_FunctionValueDto as FunctionValueDto, functions_FunctionWithdrawalReport as FunctionWithdrawalReport, functions_GetFunctionResponse as GetFunctionResponse, functions_ListFunctionsResponse as ListFunctionsResponse, functions_PatternDto as PatternDto, functions_RegisterFunctionRequest as RegisterFunctionRequest, functions_RegisterFunctionResponse as RegisterFunctionResponse, functions_ReplaceFunctionResponse as ReplaceFunctionResponse, functions_UnaryOperatorDto as UnaryOperatorDto };
 }
 
 /**
@@ -57019,6 +57330,46 @@ declare class FunctionsClient {
      * ```
      */
     listFunctions(): Promise<ListFunctionsResponse>;
+    /**
+     * Read one registered function's definition.
+     *
+     * @param name - The registered function's name — its identity.
+     * @returns The signature, everything that calls it, whether a `PUT` would
+     *   act or refuse, and the clauses in the shape a replacement takes.
+     * @throws {ApiError} 404 if nothing is registered under that name for the
+     *   authenticated tenant. Another tenant's function is 404 too — saying
+     *   anything else would confirm the name exists somewhere.
+     *
+     * @remarks
+     * This is what makes {@link FunctionsClient.replaceFunction} an edit. `PUT`
+     * replaces the WHOLE definition, so without a read a client fixing one
+     * clause of a three-clause function had to re-author the other two from
+     * memory, and any it forgot were deleted.
+     *
+     * `clauses` and `unrepresentable` are exclusive: a definition holding a
+     * construct the register shape cannot express comes back with no clauses and
+     * a reason, because a degraded read written back would destroy the real
+     * definition. Narrow on `clauses === undefined` before using them.
+     *
+     * A plugin-contributed function is refused by `DELETE`/`PUT` and returned
+     * here, with `replaceable: false` and the refusal the mutation would give.
+     *
+     * @example
+     * ```typescript
+     * const definition = await client.functions.getFunction('scale');
+     * if (definition.clauses === undefined) {
+     *   throw new Error(`scale cannot be edited: ${definition.unrepresentable}`);
+     * }
+     * if (!definition.replaceable) {
+     *   throw new Error(definition.notReplaceable?.reason);
+     * }
+     * await client.functions.replaceFunction('scale', {
+     *   arity: definition.arity,
+     *   clauses: definition.clauses.map(tweak),
+     * });
+     * ```
+     */
+    getFunction(name: string): Promise<GetFunctionResponse>;
     /**
      * Withdraw a registered function.
      *

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.25.0";
+var SDK_VERSION = "1.26.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -8491,6 +8491,22 @@ var Functions = class {
     format: "json",
     ...params
   });
+  /**
+   * @description # Why this route had to exist `/api/v1/functions` had five routes and none of them returned a definition: the listing answers summaries (`name`, `arity`, `clauses_count`, `kind`), and `GET /api/v1/functions/{name}` was a `405`. So `PUT` replaced a definition its caller could not see — a client fixing one clause of a three-clause function had to remember the other two or lose them, and the route made a partial edit look like a whole one (#235). # The clauses come back in the shape `PUT` takes [`GetFunctionResponse::clauses`] is the exact `clauses` payload `POST /functions/register` and `PUT /functions/{name}` accept, so a read-modify-write needs no translation layer that could drop a body variant on the way through. Making that true meant widening the request shape: `BinaryOperatorDto` carried four of the domain's thirteen operators and `ExpressionDto` was missing `UnaryOp` and `Conditional`, while OSFQL `DERIVE` builds function bodies with every one of them. A read in the old shape would have had to drop a `CASE WHEN` or lie about a `%`. # Reading is not changing A plugin-contributed function is refused by `DELETE` and `PUT` and **returned** by this route, with `replaceable: false` and the refusal the mutation would answer with. The listing already admits it exists; refusing to describe it would leave a client unable to show what the plugin contributed while still showing its name. The refusal is read from the same walk the mutation routes run, so the two cannot disagree. # Authorization Requires `X-Tenant-Id`. The function store is tenant-keyed, so another tenant's function is `404` rather than forbidden — saying anything else would confirm the name exists somewhere.
+   *
+   * @tags functions
+   * @name GetFunction
+   * @summary Read one registered function's definition.
+   * @request GET:/api/v1/functions/{name}
+   * @secure
+   */
+  getFunction = (name, params = {}) => this.http.request({
+    path: `/api/v1/functions/${name}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description This is the discovery counterpart to `register_function`/`evaluate_function`: it projects the tenant's slice of the function sub-lattice into a list of typed signatures (name + arity + clause count) without evaluating anything. The tenant is taken from the authenticated principal (never a body field), honouring the tenancy-scoping invariant.
    *
@@ -26173,6 +26189,23 @@ function ExpressionDtoFromFrontToApi(model) {
       right: ExpressionDtoFromFrontToApi(model.right)
     };
   }
+  if (model.type === "UnaryOp") {
+    return {
+      type: "UnaryOp",
+      op: model.op,
+      operand: ExpressionDtoFromFrontToApi(model.operand)
+    };
+  }
+  if (model.type === "Conditional") {
+    return {
+      type: "Conditional",
+      branches: model.branches.map((b) => ({
+        when: ExpressionDtoFromFrontToApi(b.when),
+        then: ExpressionDtoFromFrontToApi(b.then)
+      })),
+      default: model.default ? ExpressionDtoFromFrontToApi(model.default) : model.default
+    };
+  }
   return model;
 }
 function ExpressionDtoFromApiToFront(dto) {
@@ -26191,6 +26224,23 @@ function ExpressionDtoFromApiToFront(dto) {
       right: ExpressionDtoFromApiToFront(dto.right)
     };
   }
+  if (dto.type === "UnaryOp") {
+    return {
+      type: "UnaryOp",
+      op: dto.op,
+      operand: ExpressionDtoFromApiToFront(dto.operand)
+    };
+  }
+  if (dto.type === "Conditional") {
+    return {
+      type: "Conditional",
+      branches: dto.branches.map((b) => ({
+        when: ExpressionDtoFromApiToFront(b.when),
+        then: ExpressionDtoFromApiToFront(b.then)
+      })),
+      default: dto.default ? ExpressionDtoFromApiToFront(dto.default) : dto.default
+    };
+  }
   return dto;
 }
 function FunctionBodyDtoFromFrontToApi(model) {
@@ -26407,6 +26457,26 @@ function ReplaceFunctionResponseFromApiToFront(dto) {
     callers: (dto.callers ?? []).map(FunctionCallerFromApiToFront)
   };
 }
+function GetFunctionResponseFromApiToFront(dto) {
+  const signature = {
+    name: dto.name,
+    functionId: dto.function_id,
+    arity: dto.arity,
+    kind: dto.kind,
+    replaceable: dto.replaceable,
+    notReplaceable: dto.not_replaceable ?? void 0,
+    // The wire omits the field when nothing calls it; the SDK always hands
+    // back an array, as the withdrawal report already does.
+    callers: (dto.callers ?? []).map(FunctionCallerFromApiToFront)
+  };
+  if (dto.clauses == null) {
+    return {
+      ...signature,
+      unrepresentable: dto.unrepresentable ?? "The engine returned no clauses for this function and gave no reason."
+    };
+  }
+  return { ...signature, clauses: dto.clauses.map(FunctionClauseDtoFromApiToFront) };
+}
 
 // src/resources/functions.ts
 var FunctionsClient = class {
@@ -26470,7 +26540,9 @@ var FunctionsClient = class {
    * ```
    */
   async registerFunction(request) {
-    const response = await this.api.registerFunction(RegisterFunctionRequestFromFrontToApi(request));
+    const response = await this.api.registerFunction(
+      RegisterFunctionRequestFromFrontToApi(request)
+    );
     return RegisterFunctionResponseFromApiToFront(response.data);
   }
   /**
@@ -26521,7 +26593,9 @@ var FunctionsClient = class {
    * ```
    */
   async evaluateFunction(request) {
-    const response = await this.api.evaluateFunction(EvaluateFunctionRequestFromFrontToApi(request));
+    const response = await this.api.evaluateFunction(
+      EvaluateFunctionRequestFromFrontToApi(request)
+    );
     return EvaluateFunctionResponseFromApiToFront(response.data);
   }
   /**
@@ -26551,6 +26625,49 @@ var FunctionsClient = class {
     const response = await this.api.listFunctions();
     return ListFunctionsResponseFromApiToFront(response.data);
   }
+  /**
+   * Read one registered function's definition.
+   *
+   * @param name - The registered function's name — its identity.
+   * @returns The signature, everything that calls it, whether a `PUT` would
+   *   act or refuse, and the clauses in the shape a replacement takes.
+   * @throws {ApiError} 404 if nothing is registered under that name for the
+   *   authenticated tenant. Another tenant's function is 404 too — saying
+   *   anything else would confirm the name exists somewhere.
+   *
+   * @remarks
+   * This is what makes {@link FunctionsClient.replaceFunction} an edit. `PUT`
+   * replaces the WHOLE definition, so without a read a client fixing one
+   * clause of a three-clause function had to re-author the other two from
+   * memory, and any it forgot were deleted.
+   *
+   * `clauses` and `unrepresentable` are exclusive: a definition holding a
+   * construct the register shape cannot express comes back with no clauses and
+   * a reason, because a degraded read written back would destroy the real
+   * definition. Narrow on `clauses === undefined` before using them.
+   *
+   * A plugin-contributed function is refused by `DELETE`/`PUT` and returned
+   * here, with `replaceable: false` and the refusal the mutation would give.
+   *
+   * @example
+   * ```typescript
+   * const definition = await client.functions.getFunction('scale');
+   * if (definition.clauses === undefined) {
+   *   throw new Error(`scale cannot be edited: ${definition.unrepresentable}`);
+   * }
+   * if (!definition.replaceable) {
+   *   throw new Error(definition.notReplaceable?.reason);
+   * }
+   * await client.functions.replaceFunction('scale', {
+   *   arity: definition.arity,
+   *   clauses: definition.clauses.map(tweak),
+   * });
+   * ```
+   */
+  async getFunction(name) {
+    const response = await this.api.getFunction(name);
+    return GetFunctionResponseFromApiToFront(response.data);
+  }
   /**
    * Withdraw a registered function.
    *