Naftiko Ikanos Capability

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://ikanos.io/schemas/v1.0.0-beta2/ikanos.json",
  "name": "Ikanos Specification",
  "description": "Ikanos Capability Specification \u2014 describes a capability document (adapter + metadata) or a standalone shared file (consumes / exposes / aggregates / binds). A valid document must declare `ikanos` + exactly one of `capability`, `consumes`, `exposes`, `aggregates`, or `binds`. All adapter logic lives under `capability`; shared section definitions live at root.",
  "type": "object",
  "properties": {
    "ikanos": {
      "type": "string",
      "description": "Ikanos specification version. Signals schema compatibility \u2014 always the first key in a capability file.",
      "const": "1.0.0-beta5"
    },
    "info": {
      "$ref": "#/$defs/Info",
      "description": "Human-readable metadata: label, description, tags, dates, stakeholders.\n\n**When to use** \u2014 Required on every capability document. The richer the `description`, the better agents can discover and reason about this capability.\n**Format** \u2014 `created` / `modified` must be `YYYY-MM-DD`. `stakeholders[].role` is free-form (`owner`, `editor`, `reviewer`, etc.)."
    },
    "consumes": {
      "type": "array",
      "items": {
        "oneOf": [
          {
            "$ref": "#/$defs/ConsumesHttp"
          },
          {
            "$ref": "#/$defs/ImportEntry"
          }
        ]
      },
      "minItems": 1,
      "description": "External HTTP API adapters declared at file scope. Each entry is either an inline `ConsumesHttp` (with `type: http`) or an `ImportEntry` (with a `from` URI). Standalone consumes files use this section at root."
    },
    "exposes": {
      "type": "array",
      "items": {
        "oneOf": [
          {
            "$ref": "#/$defs/ExposesRest"
          },
          {
            "$ref": "#/$defs/ExposesMcp"
          },
          {
            "$ref": "#/$defs/ExposesSkill"
          },
          {
            "$ref": "#/$defs/ExposesControl"
          },
          {
            "$ref": "#/$defs/ImportEntry"
          }
        ]
      },
      "minItems": 1,
      "description": "Exposed server adapters declared at file scope. Each entry is either an inline adapter (rest/mcp/skill/control) or an `ImportEntry` (with a `from` URI). Standalone exposes files use this section at root."
    },
    "aggregates": {
      "type": "array",
      "items": {
        "oneOf": [
          {
            "$ref": "#/$defs/Aggregate"
          },
          {
            "$ref": "#/$defs/ImportEntry"
          }
        ]
      },
      "minItems": 1,
      "description": "Domain aggregates declared at file scope. Each entry is either an inline `Aggregate` or an `ImportEntry` (with a `from` URI). Standalone aggregates files use this section at root."
    },
    "binds": {
      "type": "array",
      "items": {
        "oneOf": [
          {
            "$ref": "#/$defs/Binding"
          },
          {
            "$ref": "#/$defs/ImportEntry"
          }
        ]
      },
      "minItems": 1,
      "description": "External variable bindings available file-wide. Each entry is either an inline `Binding` (with a runtime `location` URI such as `vault://`, `file://`, ...) or an `ImportEntry` (with a parse-time `from` URI to a shared binds file).\n\n**Example**:\n```yaml\nbinds:\n  - namespace: secrets\n    location: vault://my-vault/secret/data/app\n    keys:\n      API_KEY: api-key\n      DB_PASSWORD: db-password\n```\n**See also** \u2014 `capability.binds` for bindings scoped to a single capability."
    },
    "capability": {
      "$ref": "#/$defs/Capability",
      "description": "Technical body of the capability: what it exposes (`exposes`), what it calls (`consumes`), and shared domain logic (`aggregates`). At least one of `exposes`, `consumes`, or `aggregates` is required.\n\n**See also** \u2014 `info` for metadata, `binds` for secrets."
    }
  },
  "oneOf": [
    {
      "required": [
        "ikanos",
        "capability"
      ]
    },
    {
      "required": [
        "ikanos",
        "consumes"
      ],
      "not": {
        "required": [
          "capability"
        ]
      }
    },
    {
      "required": [
        "ikanos",
        "exposes"
      ],
      "not": {
        "required": [
          "capability"
        ]
      }
    },
    {
      "required": [
        "ikanos",
        "aggregates"
      ],
      "not": {
        "required": [
          "capability"
        ]
      }
    },
    {
      "required": [
        "ikanos",
        "binds"
      ],
      "not": {
        "required": [
          "capability"
        ]
      }
    }
  ],
  "additionalProperties": false,
  "$defs": {
    "ImportEntry": {
      "type": "object",
      "description": "Unified import directive shared by `consumes`, `exposes`, `aggregates`, and `binds`. Imports a single namespaced entry from another file by its `namespace`, optionally aliasing it locally via `as`. The `from` path is resolved relative to the importing file. Transitive imports are not supported \u2014 each source file must be a self-contained leaf.\n\n**Example**:\n```yaml\nconsumes:\n  - from: ./shared/notion-api.yml\n    import: notion\n    as: notion-shared\n```",
      "properties": {
        "from": {
          "type": "string",
          "description": "Path or URI to the file that contains the entry to import (e.g. `./shared/notion.yml` or `file:///shared/notion.yml`). Relative paths resolve against the directory of the importing file."
        },
        "import": {
          "$ref": "#/$defs/IdentifierKebab",
          "description": "Namespace of the entry to import from the referenced file."
        },
        "as": {
          "$ref": "#/$defs/IdentifierKebab",
          "description": "Optional local alias. When set, the imported entry's namespace becomes `as` in the importing document; this enables disambiguation when two sources expose the same name."
        },
        "description": {
          "type": "string",
          "description": "Human- and agent-readable description of this import. Helps agents reason about the imported entry."
        }
      },
      "required": [
        "from",
        "import"
      ],
      "additionalProperties": false
    },
    "Binding": {
      "type": "object",
      "description": "Declares that the capability binds to an external source of variables. Variables declared via 'keys' are injected using mustache-style expressions.",
      "properties": {
        "namespace": {
          "$ref": "#/$defs/IdentifierKebab",
          "description": "Unique identifier for this binding. Used as qualifier in expressions for disambiguation."
        },
        "description": {
          "type": "string",
          "description": "A meaningful description of the binding's purpose. In a world of agents, context is king."
        },
        "location": {
          "$ref": "#/$defs/UriLocation",
          "description": "URI identifying the value provider. The URI scheme expresses the resolution strategy (file://, vault://, github-secrets://, k8s-secret://, etc.). When omitted, values are injected by the runtime environment."
        },
        "keys": {
          "$ref": "#/$defs/BindingKeys",
          "description": "Map of variable names to keys in the resolved source. Each key is the variable name used for injection, each value is the corresponding key in the provider."
        }
      },
      "required": [
        "namespace",
        "keys"
      ],
      "additionalProperties": false
    },
    "UriLocation": {
      "type": "string",
      "pattern": "^[a-zA-Z][a-zA-Z0-9+.-]*://",
      "description": "A URI with an explicit scheme identifying the resource provider."
    },
    "BindingVariableName": {
      "type": "string",
      "pattern": "^[A-Z][A-Z0-9_]*$",
      "description": "Variable name for binding injection (SCREAMING_SNAKE_CASE). Enforced for visual distinction from declared parameters in expressions."
    },
    "BindingKeys": {
      "type": "object",
      "description": "Map of variable names (SCREAMING_SNAKE_CASE) to source keys in the provider.",
      "propertyNames": {
        "$ref": "#/$defs/BindingVariableName"
      },
      "additionalProperties": {
        "$ref": "#/$defs/IdentifierExtended"
      }
    },
    "IdentifierKebab": {
      "type": "string",
      "description": "Kebab-case identifier (alphanumeric and hyphens).",
      "pattern": "^[a-zA-Z0-9-]+$"
    },
    "IdentifierExtended": {
      "type": "string",
      "description": "Extended identifier (alphanumeric, hyphens, underscores, and wildcard).",
      "pattern": "^[a-zA-Z0-9-_*]+$"
    },
    "BinarySize": {
      "type": "string",
      "description": "A binary size with a mandatory unit (`B`, `KiB`, `MiB`, or `GiB`), e.g. `512KiB`, `5MiB`, `1GiB`. The unit is required to avoid ambiguity (a bare number has no scale).",
      "pattern": "^\\d+(\\.\\d+)?(B|KiB|MiB|GiB)$"
    },
    "CacheScope": {
      "type": "string",
      "description": "Controls whether shared intermediaries may cache the response.",
      "enum": [
        "public",
        "private"
      ]
    },
    "ConsumedInputParameter": {
      "type": "object",
      "description": "Describes a single function parameter. A unique parameter is defined by a combination of a name and location.",
      "properties": {
        "in": {
          "type": "string",
          "description": "Location of the parameter",
          "enum": [
            "query",
            "header",
            "path",
            "cookie",
            "body",
            "environment"
          ]
        },
        "value": {
          "type": "string",
          "description": "Value of the parameter. Can be a static value or an expression resolved from the execution context (e.g. $this.namespace.param)"
        }
      },
      "required": [
        "in"
      ],
      "additionalProperties": false
    },
    "ExposedInputParameter": {
      "type": "object",
      "description": "Declares an input parameter for an exposed resource or operation. Type and description are mandatory since the framework cannot infer them.",
      "properties": {
        "in": {
          "type": "string",
          "description": "Location of the parameter.",
          "enum": [
            "query",
            "header",
            "path",
            "cookie",
            "body"
          ]
        },
        "type": {
          "type": "string",
          "description": "The expected data type of the parameter.",
          "enum": [
            "string",
            "number",
            "integer",
            "boolean",
            "array",
            "object"
          ]
        },
        "description": {
          "type": "string",
          "description": "A meaningful description of the parameter. Used for agent discovery and human documentation."
        },
        "pattern": {
          "type": "string",
          "description": "Optional regex pattern for validation. Only applicable when type is 'string'."
        },
        "value": {
          "type": "string",
          "description": "Static value or expression resolved from the execution context."
        }
      },
      "required": [
        "in",
        "type",
        "description"
      ],
      "additionalProperties": false
    },
    "ConsumedOutputParameter": {
      "type": "object",
      "description": "Extracts a named value from the raw API response for use in orchestration steps.\n\n**When to use** \u2014 Declare one entry per piece of data you need from the response. The `value` JsonPath expression is evaluated against the parsed response body.\n**Usage** \u2014 Extracted values are referenced by their key in step `with` mappings and `MappedOutputParameter` definitions.\n**Tip** \u2014 For array responses, use JsonPath wildcards (e.g. `$.results[*].id`) to extract a list.",
      "properties": {
        "type": {
          "type": "string",
          "description": "Expected type of the extracted value. Used for type-checking in step mappings.",
          "enum": [
            "string",
            "number",
            "boolean",
            "object",
            "array"
          ]
        },
        "value": {
          "type": "string",
          "description": "JsonPath expression evaluated against the parsed response body to extract this parameter. Examples: `$.id`, `$.results[*].name`, `$.meta.total`."
        }
      },
      "required": [
        "type",
        "value"
      ],
      "unevaluatedProperties": false
    },
    "MappedOutputParameterBase": {
      "type": "object",
      "description": "Base for an inline-mapped output parameter with recursive typing and JsonPath extraction.",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "string",
            "number",
            "boolean",
            "object",
            "array"
          ]
        },
        "mapping": {
          "type": "string",
          "description": "JsonPath expression to extract the value. E.g. $.properties.Name.title[0].text.content"
        },
        "const": {
          "description": "Schema-level constant for validation and linting. Not used at runtime for value injection \u2014 use 'value' instead.",
          "oneOf": [
            {
              "type": "string"
            },
            {
              "type": "number"
            },
            {
              "type": "boolean"
            },
            {
              "type": "array"
            },
            {
              "type": "object"
            }
          ]
        },
        "value": {
          "type": "string",
          "description": "Static value injected at runtime. When provided, takes precedence over mapping."
        }
      },
      "required": [
        "type"
      ]
    },
    "MappedOutputParameterString": {
      "allOf": [
        {
          "$ref": "#/$defs/MappedOutputParameterBase"
        },
        {
          "properties": {
            "type": {
              "const": "string"
            },
            "mapping": true,
            "const": true,
            "value": true
          },
          "oneOf": [
            {
              "required": [
                "mapping"
              ]
            },
            {
              "required": [
                "value"
              ]
            }
          ]
        }
      ],
      "unevaluatedProperties": false
    },
    "MappedOutputParameterNumber": {
      "allOf": [
        {
          "$ref": "#/$defs/MappedOutputParameterBase"
        },
        {
          "properties": {
            "type": {
              "const": "number"
            },
            "mapping": true,
            "const": true,
            "value": true
          },
          "oneOf": [
            {
              "required": [
                "mapping"
              ]
            },
            {
              "required": [
                "value"
              ]
            }
          ]
        }
      ],
      "unevaluatedProperties": false
    },
    "MappedOutputParameterBoolean": {
      "allOf": [
        {
          "$ref": "#/$defs/MappedOutputParameterBase"
        },
        {
          "properties": {
            "type": {
              "const": "boolean"
            },
            "mapping": true,
            "const": true,
            "value": true
          },
          "oneOf": [
            {
              "required": [
                "mapping"
              ]
            },
            {
              "required": [
                "value"
              ]
            }
          ]
        }
      ],
      "unevaluatedProperties": false
    },
    "MappedOutputParameterObject": {
      "allOf": [
        {
          "$ref": "#/$defs/MappedOutputParameterBase"
        },
        {
          "properties": {
            "type": {
              "const": "object"
            },
            "mapping": true,
            "const": true,
            "value": true,
            "properties": {
              "type": "object",
              "description": "A map of named properties. Each key is a property name, each value is a typed output parameter.",
              "additionalProperties": {
                "$ref": "#/$defs/MappedOutputParameter"
              }
            }
          },
          "required": [
            "properties"
          ]
        }
      ],
      "unevaluatedProperties": false
    },
    "MappedOutputParameterArray": {
      "allOf": [
        {
          "$ref": "#/$defs/MappedOutputParameterBase"
        },
        {
          "properties": {
            "type": {
              "const": "array"
            },
            "mapping": true,
            "const": true,
            "value": true,
            "items": {
              "$ref": "#/$defs/MappedOutputParameter"
            }
          },
          "required": [
            "items"
          ]
        }
      ],
      "unevaluatedProperties": false
    },
    "MappedOutputParameter": {
      "description": "Inline-mapped output parameter (simple mode). Used when the exposed operation has a single call + with.",
      "oneOf": [
        {
          "$ref": "#/$defs/MappedOutputParameterString"
        },
        {
          "$ref": "#/$defs/MappedOutputParameterNumber"
        },
        {
          "$ref": "#/$defs/MappedOutputParameterBoolean"
        },
        {
          "$ref": "#/$defs/MappedOutputParameterObject"
        },
        {
          "$ref": "#/$defs/MappedOutputParameterArray"
        }
      ]
    },
    "OrchestratedOutputParameterBase": {
      "type": "object",
      "description": "Base for a named output parameter whose value is populated by step mappings during orchestration.",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "string",
            "number",
            "boolean",
            "object",
            "array"
          ]
        }
      },
      "required": [
        "type"
      ]
    },
    "OrchestratedOutputParameterScalar": {
      "allOf": [
        {
          "$ref": "#/$defs/OrchestratedOutputParameterBase"
        },
        {
          "properties": {
            "type": {
              "enum": [
                "string",
                "number",
                "boolean"
              ]
            }
          }
        }
      ],
      "unevaluatedProperties": false
    },
    "OrchestratedOutputParameterArray": {
      "allOf": [
        {
          "$ref": "#/$defs/OrchestratedOutputParameterBase"
        },
        {
          "properties": {
            "type": {
              "const": "array"
            },
            "items": {
              "type": "object",
              "additionalProperties": {
                "$ref": "#/$defs/OrchestratedOutputParameter"
              },
              "minProperties": 1
            }
          },
          "required": [
            "items"
          ]
        }
      ],
      "unevaluatedProperties": false
    },
    "OrchestratedOutputParameterObject": {
      "allOf": [
        {
          "$ref": "#/$defs/OrchestratedOutputParameterBase"
        },
        {
          "properties": {
            "type": {
              "const": "object"
            },
            "properties": {
              "type": "object",
              "additionalProperties": {
                "$ref": "#/$defs/OrchestratedOutputParameter"
              }
            }
          },
          "required": [
            "properties"
          ]
        }
      ],
      "unevaluatedProperties": false
    },
    "OrchestratedOutputParameter": {
      "description": "Named output parameter (orchestrated mode). Used when the exposed operation has steps with mappings/lookups.",
      "oneOf": [
        {
          "$ref": "#/$defs/OrchestratedOutputParameterScalar"
        },
        {
          "$ref": "#/$defs/OrchestratedOutputParameterArray"
        },
        {
          "$ref": "#/$defs/OrchestratedOutputParameterObject"
        }
      ]
    },
    "MockOutputParameter": {
      "type": "object",
      "description": "Named output parameter with a static or template value for mock mode (no call or steps). The value field supports Mustache templates resolved against input parameters at runtime.",
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "string",
            "number",
            "boolean"
          ]
        },
        "value": {
          "type": "string",
          "description": "Static value or Mustache template resolved against input parameters at runtime."
        }
      },
      "required": [
        "type",
        "value"
      ],
      "unevaluatedProperties": false
    },
    "Hostname": {
      "type": "string",
      "description": "Valid hostname",
      "pattern": "^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)(\\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
    },
    "IPv4": {
      "type": "string",
      "description": "Valid IPv4 address",
      "pattern": "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
    },
    "IPv6": {
      "type": "string",
      "description": "Valid IPv6 address (simplified)",
      "pattern": "^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$"
    },
    "Address": {
      "description": "hostname or IP for the exposition",
      "anyOf": [
        {
          "$ref": "#/$defs/Hostname"
        },
        {
          "$ref": "#/$defs/IPv4"
        },
        {
          "$ref": "#/$defs/IPv6"
        }
      ]
    },
    "Info": {
      "type": "object",
      "description": "Information about the capability",
      "properties": {
        "display": {
          "type": "string",
          "description": "The display name of the capability"
        },
        "description": {
          "type": "string",
          "description": "A description of the capability (the more meaningful, the easier for agents discovery)"
        },
        "tags": {
          "type": "array",
          "description": "List of tags to help categorize the capability. It can be used for discovery and filtering purposes.",
          "items": {
            "type": "string"
          }
        },
        "created": {
          "type": "string",
          "pattern": "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
          "description": "The date when the capability was created"
        },
        "modified": {
          "type": "string",
          "pattern": "^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
          "description": "The date when the capability was last modified"
        },
        "version": {
          "type": "string",
          "description": "The version of the capability"
        },
        "stakeholders": {
          "type": "array",
          "description": "List of stakeholders related to this capability. It can be used for discovery and filtering purposes.",
          "items": {
            "$ref": "#/$defs/Person"
          }
        }
      },
      "required": [
        "display",
        "description"
      ],
      "additionalProperties": false
    },
    "Person": {
      "type": "object",
      "description": "A person related to the capability",
      "properties": {
        "role": {
          "type": "string",
          "description": "The role of the person in relation to the capability. E.g. owner, editor, viewer"
        },
        "fullName": {
          "type": "string",
          "description": "The full name of the person"
        },
        "email": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}$",
          "description": "The email address of the person"
        }
      },
      "required": [
        "role",
        "fullName"
      ],
      "additionalProperties": false
    },
    "Capability": {
      "type": "object",
      "description": "Capability technical configuration",
      "properties": {
        "binds": {
          "type": "array",
          "items": {
            "oneOf": [
              {
                "$ref": "#/$defs/Binding"
              },
              {
                "$ref": "#/$defs/ImportEntry"
              }
            ]
          },
          "minItems": 1,
          "description": "External sources the capability binds to for variable injection. Inline `Binding` entries or `ImportEntry` references to a shared binds file."
        },
        "exposes": {
          "type": "array",
          "description": "List of exposed server adapters. Inline adapters (rest/mcp/skill/control) or `ImportEntry` references to a shared exposes file.",
          "items": {
            "oneOf": [
              {
                "$ref": "#/$defs/ExposesRest"
              },
              {
                "$ref": "#/$defs/ExposesMcp"
              },
              {
                "$ref": "#/$defs/ExposesSkill"
              },
              {
                "$ref": "#/$defs/ExposesControl"
              },
              {
                "$ref": "#/$defs/ImportEntry"
              }
            ]
          },
          "minItems": 1
        },
        "consumes": {
          "type": "array",
          "description": "Consumed client adapters. Inline `ConsumesHttp` entries or `ImportEntry` references to a shared consumes file.",
          "items": {
            "oneOf": [
              {
                "$ref": "#/$defs/ConsumesHttp"
              },
              {
                "$ref": "#/$defs/ImportEntry"
              }
            ]
          },
          "minItems": 1
        },
        "aggregates": {
          "type": "array",
          "description": "Domain aggregates defining reusable functions that adapters can reference via ref. Inline `Aggregate` entries or `ImportEntry` references to a shared aggregates file.",
          "items": {
            "oneOf": [
              {
                "$ref": "#/$defs/Aggregate"
              },
              {
                "$ref": "#/$defs/ImportEntry"
              }
            ]
          },
          "minItems": 1
        }
      },
      "anyOf": [
        {
          "required": [
            "exposes"
          ]
        },
        {
          "required": [
            "consumes"
          ]
        },
        {
          "required": [
            "exposes",
            "consumes"
          ]
        }
      ],
      "additionalProperties": false
    },
    "Aggregate": {
      "type": "object",
      "description": "A domain aggregate grouping reusable flows. Adapters reference these flows via ref.",
      "properties": {
        "display": {
          "type": "string",
          "description": "Human-readable name for this aggregate (e.g. 'Forecast')."
        },
        "namespace": {
          "$ref": "#/$defs/IdentifierKebab",
          "description": "Machine-readable qualifier for this aggregate. Used as the first segment in ref values. Must match the map key."
        },
        "flows": {
          "type": "object",
          "propertyNames": {
            "$ref": "#/$defs/IdentifierKebab"
          },
          "additionalProperties": {
            "$ref": "#/$defs/AggregateFlow"
          },
          "description": "Reusable callable flows within this aggregate, keyed by flow name.",
          "minProperties": 1
        }
      },
      "required": [
        "display",
        "flows"
      ],
      "additionalProperties": false
    },
    "AggregateFlow": {
      "type": "object",
      "description": "A reusable callable flow within an aggregate. Adapter units reference it via ref: aggregate-namespace.flow-name.",
      "properties": {
        "description": {
          "type": "string",
          "description": "A meaningful description of the flow."
        },
        "tags": {
          "type": "array",
          "description": "Arbitrary string tags for filtering and discovery.",
          "items": {
            "type": "string"
          }
        },
        "semantics": {
          "$ref": "#/$defs/Semantics"
        },
        "outputMediaType": {
          "type": "string",
          "description": "Contract-level media type advertised by this flow to downstream `exposes`. Independent of `outputRawFormat`, which is always inherited from the underlying consumed operation (call:) or the terminal step (steps:). Overrides the consumed op's `outputMediaType` for advertisement only; never changes how the entity is parsed."
        },
        "inputParameters": {
          "type": "object",
          "propertyNames": {
            "pattern": "^[a-zA-Z0-9-_*]+$"
          },
          "additionalProperties": {
            "$ref": "#/$defs/McpToolInputParameter"
          },
          "description": "Function input parameters, keyed by parameter name."
        },
        "call": {
          "type": "string",
          "description": "Reference to the consumed operation. Format: {namespace}.{operationId}.",
          "pattern": "^[a-zA-Z0-9-]+\\.[a-zA-Z0-9-]+$"
        },
        "with": {
          "$ref": "#/$defs/WithInjector"
        },
        "steps": {
          "type": "object",
          "propertyNames": {
            "$ref": "#/$defs/IdentifierKebab"
          },
          "additionalProperties": {
            "$ref": "#/$defs/OperationStep"
          },
          "description": "Orchestration steps, keyed by step name.",
          "minProperties": 1
        },
        "mappings": {
          "type": "array",
          "description": "Maps step outputs to the function's output parameters.",
          "items": {
            "$ref": "#/$defs/StepOutputMapping"
          }
        },
        "outputParameters": true
      },
      "required": [
        "description"
      ],
      "anyOf": [
        {
          "required": [
            "call"
          ],
          "type": "object",
          "properties": {
            "outputParameters": {
              "type": "array",
              "items": {
                "$ref": "#/$defs/MappedOutputParameter"
              }
            }
          }
        },
        {
          "required": [
            "steps"
          ],
          "type": "object",
          "properties": {
            "mappings": true,
            "outputParameters": {
              "type": "object",
              "additionalProperties": {
                "$ref": "#/$defs/OrchestratedOutputParameter"
              }
            }
          }
        },
        {
          "required": [
            "outputParameters"
          ],
          "type": "object",
          "properties": {
            "outputParameters": {
              "type": "object",
              "additionalProperties": {
                "$ref": "#/$defs/MockOutputParameter"
              },
              "minProperties": 1
            }
          }
        }
      ],
      "additionalProperties": false
    },
    "Semantics": {
      "type": "object",
      "description": "Transport-neutral behavioral metadata for an invocable unit. Used for design-time tooling and adapter derivations (e.g. MCP hints).",
      "properties": {
        "safe": {
          "type": "boolean",
          "description": "If true, the function does not modify state. Default: false."
        },
        "idempotent": {
          "type": "boolean",
          "description": "If true, repeating the call has no additional effect. Default: false."
        },
        "cacheable": {
          "type": "boolean",
          "description": "If true, the result can be cached. Default: false."
        }
      },
      "additionalProperties": false
    },
    "ExposesRest": {
      "type": "object",
      "description": "REST exposition configuration",
      "properties": {
        "type": {
          "type": "string",
          "const": "rest"
        },
        "address": {
          "$ref": "#/$defs/Address"
        },
        "port": {
          "type": "integer",
          "minimum": 1,
          "maximum": 65535
        },
        "namespace": {
          "$ref": "#/$defs/IdentifierKebab",
          "description": "Unique identifier for this exposed API"
        },
        "authentication": {
          "$ref": "#/$defs/Authentication",
          "description": "Authentication required on incoming requests to this REST adapter. Protects all resources and operations under this adapter. Supports `basic`, `apikey`, `bearer`, `digest`, and `oauth2` (JWT/introspection)."
        },
        "maxBinarySize": {
          "$ref": "#/$defs/BinarySize",
          "description": "Maximum allowed binary response size before 

# --- truncated at 32 KB (104 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/naftiko/refs/heads/main/json-schema/naftiko-ikanos-capability-schema.json