@nirmos/sdk 0.2.0 → 0.3.2

package/src/management/resources.ts

@@ -0,0 +1,198 @@
+// Generated from HTTP contracts and curated SDK namespaces.
+import type { HttpTransport } from "../core/transport.js";
+import type { RequestOptions } from "../core/types.js";
+import type { Requests, Queries, Responses } from "./contracts.js";
+export function managementResources(transport: HttpTransport) { return { providers: { list: (query: Queries["listProviders"] = {}, options?: RequestOptions) => transport.data<Responses["listProviders"]>({ method: "GET", path: `/v1/providers`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getProvider"]>({ method: "GET", path: `/v1/providers/${encodeURIComponent(id)}`, options }),
+create: (body: Requests["createProvider"], options?: RequestOptions) => transport.data<Responses["createProvider"]>({ method: "POST", path: `/v1/providers`, body, options }),
+update: (id: string, body: Requests["updateProvider"], options?: RequestOptions) => transport.data<Responses["updateProvider"]>({ method: "PATCH", path: `/v1/providers/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteProvider"]>({ method: "DELETE", path: `/v1/providers/${encodeURIComponent(id)}`, options }),
+health: (options?: RequestOptions) => transport.data<Responses["providerHealth"]>({ method: "GET", path: `/v1/providers/health`, options }) },
+models: { list: (query: Queries["listModels"] = {}, options?: RequestOptions) => transport.data<Responses["listModels"]>({ method: "GET", path: `/v1/models`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getModel"]>({ method: "GET", path: `/v1/models/${encodeURIComponent(id)}`, options }),
+create: (body: Requests["createModel"], options?: RequestOptions) => transport.data<Responses["createModel"]>({ method: "POST", path: `/v1/models`, body, options }),
+update: (id: string, body: Requests["updateModel"], options?: RequestOptions) => transport.data<Responses["updateModel"]>({ method: "PATCH", path: `/v1/models/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteModel"]>({ method: "DELETE", path: `/v1/models/${encodeURIComponent(id)}`, options }),
+promptOptions: (query: Queries["promptModelOptions"] = {}, options?: RequestOptions) => transport.data<Responses["promptModelOptions"]>({ method: "GET", path: `/v1/models/prompt-options`, query, options }) },
+providerCredentials: { list: (query: Queries["listCredentials"] = {}, options?: RequestOptions) => transport.data<Responses["listCredentials"]>({ method: "GET", path: `/v1/provider-credentials`, query, options }),
+create: (body: Requests["createCredential"], options?: RequestOptions) => transport.data<Responses["createCredential"]>({ method: "POST", path: `/v1/provider-credentials`, body, options }),
+update: (id: string, body: Requests["updateCredential"], options?: RequestOptions) => transport.data<Responses["updateCredential"]>({ method: "PATCH", path: `/v1/provider-credentials/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteCredential"]>({ method: "DELETE", path: `/v1/provider-credentials/${encodeURIComponent(id)}`, options }),
+validate: (id: string, options?: RequestOptions) => transport.data<Responses["validateCredential"]>({ method: "POST", path: `/v1/provider-credentials/${encodeURIComponent(id)}/validate`, options }) },
+prompts: { list: (query: Queries["listPrompts"] = {}, options?: RequestOptions) => transport.data<Responses["listPrompts"]>({ method: "GET", path: `/v1/prompts`, query, options }),
+get: (id: string, query: Queries["getPrompt"] = {}, options?: RequestOptions) => transport.data<Responses["getPrompt"]>({ method: "GET", path: `/v1/prompts/${encodeURIComponent(id)}`, query, options }),
+create: (body: Requests["createPrompt"], options?: RequestOptions) => transport.data<Responses["createPrompt"]>({ method: "POST", path: `/v1/prompts`, body, options }),
+update: (id: string, body: Requests["updatePrompt"], options?: RequestOptions) => transport.data<Responses["updatePrompt"]>({ method: "PATCH", path: `/v1/prompts/${encodeURIComponent(id)}`, body, options }),
+duplicate: (id: string, options?: RequestOptions) => transport.data<Responses["duplicatePromptAction"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/duplicate`, options }),
+archive: (id: string, options?: RequestOptions) => transport.data<Responses["archivePromptAction"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/archive`, options }),
+restore: (id: string, options?: RequestOptions) => transport.data<Responses["unarchivePromptAction"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/restore`, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deletePromptAction"]>({ method: "DELETE", path: `/v1/prompts/${encodeURIComponent(id)}`, options }),
+versions: { list: (id: string, query: Queries["listPromptVersions"] = {}, options?: RequestOptions) => transport.data<Responses["listPromptVersions"]>({ method: "GET", path: `/v1/prompts/${encodeURIComponent(id)}/versions`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getPromptVersion"]>({ method: "GET", path: `/v1/prompt-versions/${encodeURIComponent(id)}`, options }),
+create: (id: string, body: Requests["createPromptVersion"], options?: RequestOptions) => transport.data<Responses["createPromptVersion"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/versions`, body, options }),
+publish: (id: string, versionId: string, options?: RequestOptions) => transport.data<Responses["publishPromptVersion"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}/publish`, options }) },
+branches: { list: (id: string, query: Queries["listPromptBranches"] = {}, options?: RequestOptions) => transport.data<Responses["listPromptBranches"]>({ method: "GET", path: `/v1/prompts/${encodeURIComponent(id)}/branches`, query, options }),
+create: (id: string, body: Requests["createPromptBranch"], options?: RequestOptions) => transport.data<Responses["createPromptBranch"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/branches`, body, options }),
+merge: (id: string, body: Requests["mergePromptBranches"], options?: RequestOptions) => transport.data<Responses["mergePromptBranches"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/branches/merge`, body, options }),
+delete: (id: string, branchId: string, options?: RequestOptions) => transport.data<Responses["deletePromptBranch"]>({ method: "DELETE", path: `/v1/prompts/${encodeURIComponent(id)}/branches/${encodeURIComponent(branchId)}`, options }) },
+preview: (id: string, body: Requests["simulatePromptPreview"], options?: RequestOptions) => transport.data<Responses["simulatePromptPreview"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/preview`, body, options }),
+compile: (id: string, body: Requests["compilePromptPreview"], options?: RequestOptions) => transport.data<Responses["compilePromptPreview"]>({ method: "POST", path: `/v1/prompts/${encodeURIComponent(id)}/compile`, body, options }) },
+routes: { list: (query: Queries["listRoutes"] = {}, options?: RequestOptions) => transport.data<Responses["listRoutes"]>({ method: "GET", path: `/v1/routes`, query, options }),
+editor: (id: string, options?: RequestOptions) => transport.data<Responses["getRouteEditor"]>({ method: "GET", path: `/v1/routes/${encodeURIComponent(id)}/editor`, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getRoute"]>({ method: "GET", path: `/v1/routes/${encodeURIComponent(id)}`, options }),
+create: (body: Requests["createRoute"], options?: RequestOptions) => transport.data<Responses["createRoute"]>({ method: "POST", path: `/v1/routes`, body, options }),
+update: (id: string, body: Requests["updateRoute"], options?: RequestOptions) => transport.data<Responses["updateRoute"]>({ method: "PATCH", path: `/v1/routes/${encodeURIComponent(id)}`, body, options }),
+duplicate: (id: string, options?: RequestOptions) => transport.data<Responses["duplicateRoute"]>({ method: "POST", path: `/v1/routes/${encodeURIComponent(id)}/duplicate`, options }),
+setStatus: (id: string, body: Requests["setRouteStatus"], options?: RequestOptions) => transport.data<Responses["setRouteStatus"]>({ method: "POST", path: `/v1/routes/${encodeURIComponent(id)}/status`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteRoute"]>({ method: "DELETE", path: `/v1/routes/${encodeURIComponent(id)}`, options }),
+reorder: (body: Requests["reorderRoutes"], options?: RequestOptions) => transport.data<Responses["reorderRoutes"]>({ method: "POST", path: `/v1/routes/reorder`, body, options }) },
+endpoints: { list: (query: Queries["listEndpoints"] = {}, options?: RequestOptions) => transport.data<Responses["listEndpoints"]>({ method: "GET", path: `/v1/endpoints`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getEndpoint"]>({ method: "GET", path: `/v1/endpoints/${encodeURIComponent(id)}`, options }),
+promptOptions: (query: Queries["endpointPromptOptions"] = {}, options?: RequestOptions) => transport.data<Responses["endpointPromptOptions"]>({ method: "GET", path: `/v1/endpoints/prompt-options`, query, options }),
+overview: (query: Queries["endpointOverview"] = {}, options?: RequestOptions) => transport.data<Responses["endpointOverview"]>({ method: "GET", path: `/v1/endpoints/overview`, query, options }),
+create: (body: Requests["createEndpoint"], options?: RequestOptions) => transport.data<Responses["createEndpoint"]>({ method: "POST", path: `/v1/endpoints`, body, options }),
+update: (id: string, body: Requests["updateEndpoint"], options?: RequestOptions) => transport.data<Responses["updateEndpoint"]>({ method: "PATCH", path: `/v1/endpoints/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteEndpointAction"]>({ method: "DELETE", path: `/v1/endpoints/${encodeURIComponent(id)}`, options }),
+duplicate: (id: string, options?: RequestOptions) => transport.data<Responses["duplicateEndpointAction"]>({ method: "POST", path: `/v1/endpoints/${encodeURIComponent(id)}/duplicate`, options }),
+archive: (id: string, options?: RequestOptions) => transport.data<Responses["archiveEndpointAction"]>({ method: "POST", path: `/v1/endpoints/${encodeURIComponent(id)}/archive`, options }),
+setStatus: (id: string, body: Requests["setEndpointStatus"], options?: RequestOptions) => transport.data<Responses["setEndpointStatus"]>({ method: "POST", path: `/v1/endpoints/${encodeURIComponent(id)}/status`, body, options }) },
+evaluations: { suites: { list: (query: Queries["listEvaluationsuites"] = {}, options?: RequestOptions) => transport.data<Responses["listEvaluationsuites"]>({ method: "GET", path: `/v1/evaluations/suites`, query, options }),
+get: (id: string, query: Queries["getEvaluationsuites"] = {}, options?: RequestOptions) => transport.data<Responses["getEvaluationsuites"]>({ method: "GET", path: `/v1/evaluations/suites/${encodeURIComponent(id)}`, query, options }),
+create: (body: Requests["createEvaluationsuites"], options?: RequestOptions) => transport.data<Responses["createEvaluationsuites"]>({ method: "POST", path: `/v1/evaluations/suites`, body, options }),
+update: (id: string, body: Requests["updateEvaluationsuites"], options?: RequestOptions) => transport.data<Responses["updateEvaluationsuites"]>({ method: "PATCH", path: `/v1/evaluations/suites/${encodeURIComponent(id)}`, body, options }),
+duplicate: (id: string, body: Requests["duplicateEvaluationsuites"], options?: RequestOptions) => transport.data<Responses["duplicateEvaluationsuites"]>({ method: "POST", path: `/v1/evaluations/suites/${encodeURIComponent(id)}/duplicate`, body, options }),
+archive: (id: string, options?: RequestOptions) => transport.data<Responses["archiveEvaluationsuites"]>({ method: "POST", path: `/v1/evaluations/suites/${encodeURIComponent(id)}/archive`, options }),
+restore: (id: string, options?: RequestOptions) => transport.data<Responses["restoreEvaluationsuites"]>({ method: "POST", path: `/v1/evaluations/suites/${encodeURIComponent(id)}/restore`, options }),
+dataset: (id: string, options?: RequestOptions) => transport.data<Responses["getSuiteDataset"]>({ method: "GET", path: `/v1/evaluations/suites/${encodeURIComponent(id)}/dataset`, options }),
+workspace: (id: string, query: Queries["getSuiteWorkspace"] = {}, options?: RequestOptions) => transport.data<Responses["getSuiteWorkspace"]>({ method: "GET", path: `/v1/evaluations/suites/${encodeURIComponent(id)}/workspace`, query, options }),
+columns: { reorder: (id: string, body: Requests["reorderEvaluationColumns"], options?: RequestOptions) => transport.data<Responses["reorderEvaluationColumns"]>({ method: "POST", path: `/v1/evaluations/suites/${encodeURIComponent(id)}/columns/reorder`, body, options }) } },
+datasets: { list: (query: Queries["listEvaluationdatasets"] = {}, options?: RequestOptions) => transport.data<Responses["listEvaluationdatasets"]>({ method: "GET", path: `/v1/evaluations/datasets`, query, options }),
+get: (id: string, query: Queries["getEvaluationdatasets"] = {}, options?: RequestOptions) => transport.data<Responses["getEvaluationdatasets"]>({ method: "GET", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}`, query, options }),
+create: (body: Requests["createEvaluationdatasets"], options?: RequestOptions) => transport.data<Responses["createEvaluationdatasets"]>({ method: "POST", path: `/v1/evaluations/datasets`, body, options }),
+update: (id: string, body: Requests["updateEvaluationdatasets"], options?: RequestOptions) => transport.data<Responses["updateEvaluationdatasets"]>({ method: "PATCH", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}`, body, options }),
+duplicate: (id: string, body: Requests["duplicateEvaluationdatasets"], options?: RequestOptions) => transport.data<Responses["duplicateEvaluationdatasets"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/duplicate`, body, options }),
+archive: (id: string, options?: RequestOptions) => transport.data<Responses["archiveEvaluationdatasets"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/archive`, options }),
+restore: (id: string, options?: RequestOptions) => transport.data<Responses["restoreEvaluationdatasets"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/restore`, options }),
+versions: { create: (id: string, body: Requests["newDatasetVersion"], options?: RequestOptions) => transport.data<Responses["newDatasetVersion"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/versions`, body, options }),
+freeze: (id: string, versionId: string, options?: RequestOptions) => transport.data<Responses["freezeDatasetVersion"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}/freeze`, options }),
+list: (id: string, query: Queries["listEvaluationVersions_datasets"] = {}, options?: RequestOptions) => transport.data<Responses["listEvaluationVersions_datasets"]>({ method: "GET", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/versions`, query, options }) },
+cases: { list: (id: string, query: Queries["listDatasetCases"] = {}, options?: RequestOptions) => transport.data<Responses["listDatasetCases"]>({ method: "GET", path: `/v1/evaluations/dataset-versions/${encodeURIComponent(id)}/cases`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getDatasetCase"]>({ method: "GET", path: `/v1/evaluations/cases/${encodeURIComponent(id)}`, options }),
+create: (id: string, body: Requests["createDatasetCase"], options?: RequestOptions) => transport.data<Responses["createDatasetCase"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/cases`, body, options }),
+update: (id: string, caseId: string, body: Requests["updateDatasetCase"], options?: RequestOptions) => transport.data<Responses["updateDatasetCase"]>({ method: "PATCH", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/cases/${encodeURIComponent(caseId)}`, body, options }),
+deleteBatch: (id: string, body: Requests["deleteDatasetCases"], options?: RequestOptions) => transport.data<Responses["deleteDatasetCases"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/cases/delete`, body, options }),
+import: (id: string, body: Requests["importDatasetCases"], options?: RequestOptions) => transport.data<Responses["importDatasetCases"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/cases/import`, body, options }) },
+columns: { create: (id: string, body: Requests["createDatasetColumn"], options?: RequestOptions) => transport.data<Responses["createDatasetColumn"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/columns`, body, options }),
+update: (id: string, columnId: string, body: Requests["updateDatasetColumn"], options?: RequestOptions) => transport.data<Responses["updateDatasetColumn"]>({ method: "PATCH", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/columns/${encodeURIComponent(columnId)}`, body, options }),
+delete: (id: string, columnId: string, options?: RequestOptions) => transport.data<Responses["deleteDatasetColumn"]>({ method: "DELETE", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/columns/${encodeURIComponent(columnId)}`, options }),
+reorder: (id: string, body: Requests["reorderDatasetColumns"], options?: RequestOptions) => transport.data<Responses["reorderDatasetColumns"]>({ method: "POST", path: `/v1/evaluations/datasets/${encodeURIComponent(id)}/columns/reorder`, body, options }) },
+importTrace: (body: Requests["importTraceToDataset"], options?: RequestOptions) => transport.data<Responses["importTraceToDataset"]>({ method: "POST", path: `/v1/evaluations/datasets/import-trace`, body, options }),
+importTraces: (body: Requests["importTracesToDataset"], options?: RequestOptions) => transport.data<Responses["importTracesToDataset"]>({ method: "POST", path: `/v1/evaluations/datasets/import-traces`, body, options }) },
+evaluators: { list: (query: Queries["listEvaluationevaluators"] = {}, options?: RequestOptions) => transport.data<Responses["listEvaluationevaluators"]>({ method: "GET", path: `/v1/evaluations/evaluators`, query, options }),
+get: (id: string, query: Queries["getEvaluationevaluators"] = {}, options?: RequestOptions) => transport.data<Responses["getEvaluationevaluators"]>({ method: "GET", path: `/v1/evaluations/evaluators/${encodeURIComponent(id)}`, query, options }),
+create: (body: Requests["createEvaluationevaluators"], options?: RequestOptions) => transport.data<Responses["createEvaluationevaluators"]>({ method: "POST", path: `/v1/evaluations/evaluators`, body, options }),
+update: (id: string, body: Requests["updateEvaluationevaluators"], options?: RequestOptions) => transport.data<Responses["updateEvaluationevaluators"]>({ method: "PATCH", path: `/v1/evaluations/evaluators/${encodeURIComponent(id)}`, body, options }),
+duplicate: (id: string, body: Requests["duplicateEvaluationevaluators"], options?: RequestOptions) => transport.data<Responses["duplicateEvaluationevaluators"]>({ method: "POST", path: `/v1/evaluations/evaluators/${encodeURIComponent(id)}/duplicate`, body, options }),
+archive: (id: string, options?: RequestOptions) => transport.data<Responses["archiveEvaluationevaluators"]>({ method: "POST", path: `/v1/evaluations/evaluators/${encodeURIComponent(id)}/archive`, options }),
+restore: (id: string, options?: RequestOptions) => transport.data<Responses["restoreEvaluationevaluators"]>({ method: "POST", path: `/v1/evaluations/evaluators/${encodeURIComponent(id)}/restore`, options }),
+fromTemplate: (body: Requests["createEvaluatorFromTemplate"], options?: RequestOptions) => transport.data<Responses["createEvaluatorFromTemplate"]>({ method: "POST", path: `/v1/evaluations/evaluators/from-template`, body, options }),
+versions: { create: (id: string, body: Requests["createEvaluatorVersion"], options?: RequestOptions) => transport.data<Responses["createEvaluatorVersion"]>({ method: "POST", path: `/v1/evaluations/evaluators/${encodeURIComponent(id)}/versions`, body, options }),
+list: (id: string, query: Queries["listEvaluationVersions_evaluators"] = {}, options?: RequestOptions) => transport.data<Responses["listEvaluationVersions_evaluators"]>({ method: "GET", path: `/v1/evaluations/evaluators/${encodeURIComponent(id)}/versions`, query, options }) } },
+selectors: (query: Queries["evaluationSelectors"] = {}, options?: RequestOptions) => transport.data<Responses["evaluationSelectors"]>({ method: "GET", path: `/v1/evaluations/selectors`, query, options }),
+runs: { list: (query: Queries["listPersistedEvaluationRuns"] = {}, options?: RequestOptions) => transport.data<Responses["listPersistedEvaluationRuns"]>({ method: "GET", path: `/v1/evaluations/runs`, query, options }),
+summary: (id: string, options?: RequestOptions) => transport.data<Responses["persistedEvaluationRun"]>({ method: "GET", path: `/v1/evaluations/runs/${encodeURIComponent(id)}`, options }) },
+failures: (options?: RequestOptions) => transport.data<Responses["evaluationfailures"]>({ method: "GET", path: `/v1/evaluations/failures`, options }),
+traceCandidates: (options?: RequestOptions) => transport.data<Responses["evaluationtrace-candidates"]>({ method: "GET", path: `/v1/evaluations/trace-candidates`, options }),
+columns: { create: (body: Requests["createEvaluationColumn"], options?: RequestOptions) => transport.data<Responses["createEvaluationColumn"]>({ method: "POST", path: `/v1/evaluations/columns`, body, options }),
+update: (id: string, body: Requests["updateEvaluationColumn"], options?: RequestOptions) => transport.data<Responses["updateEvaluationColumn"]>({ method: "PATCH", path: `/v1/evaluations/columns/${encodeURIComponent(id)}`, body, options }),
+duplicate: (id: string, options?: RequestOptions) => transport.data<Responses["duplicateEvaluationColumnAction"]>({ method: "POST", path: `/v1/evaluations/columns/${encodeURIComponent(id)}/duplicate`, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteEvaluationColumnAction"]>({ method: "DELETE", path: `/v1/evaluations/columns/${encodeURIComponent(id)}`, options }) },
+segments: { create: (body: Requests["createSegment"], options?: RequestOptions) => transport.data<Responses["createSegment"]>({ method: "POST", path: `/v1/evaluations/segments`, body, options }),
+update: (id: string, body: Requests["updateSegment"], options?: RequestOptions) => transport.data<Responses["updateSegment"]>({ method: "PATCH", path: `/v1/evaluations/segments/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteSegment"]>({ method: "DELETE", path: `/v1/evaluations/segments/${encodeURIComponent(id)}`, options }) },
+releasePolicies: { create: (body: Requests["createReleasePolicy"], options?: RequestOptions) => transport.data<Responses["createReleasePolicy"]>({ method: "POST", path: `/v1/evaluations/release-policies`, body, options }),
+update: (id: string, body: Requests["updateReleasePolicy"], options?: RequestOptions) => transport.data<Responses["updateReleasePolicy"]>({ method: "PATCH", path: `/v1/evaluations/release-policies/${encodeURIComponent(id)}`, body, options }),
+versions: { create: (id: string, body: Requests["createReleasePolicyVersion"], options?: RequestOptions) => transport.data<Responses["createReleasePolicyVersion"]>({ method: "POST", path: `/v1/evaluations/release-policies/${encodeURIComponent(id)}/versions`, body, options }),
+list: (id: string, query: Queries["listEvaluationVersions_release-policies"] = {}, options?: RequestOptions) => transport.data<Responses["listEvaluationVersions_release-policies"]>({ method: "GET", path: `/v1/evaluations/release-policies/${encodeURIComponent(id)}/versions`, query, options }) } },
+experiments: { prepare: (body: Requests["prepareEvaluationExperiment"], options?: RequestOptions) => transport.data<Responses["prepareEvaluationExperiment"]>({ method: "POST", path: `/v1/evaluations/experiments/prepare`, body, options }) },
+reviews: { list: (query: Queries["listHumanReviews"] = {}, options?: RequestOptions) => transport.data<Responses["listHumanReviews"]>({ method: "GET", path: `/v1/evaluations/reviews`, query, options }),
+filterOptions: (options?: RequestOptions) => transport.data<Responses["reviewFilterOptions"]>({ method: "GET", path: `/v1/evaluations/reviews/filter-options`, options }),
+runCounts: (id: string, options?: RequestOptions) => transport.data<Responses["reviewRunCounts"]>({ method: "GET", path: `/v1/evaluations/runs/${encodeURIComponent(id)}/review-counts`, options }),
+get: (body: Requests["getHumanReview"], options?: RequestOptions) => transport.data<Responses["getHumanReview"]>({ method: "POST", path: `/v1/evaluations/reviews/lookup`, body, options }),
+scoreSummaries: (body: Requests["reviewScoreSummaries"], options?: RequestOptions) => transport.data<Responses["reviewScoreSummaries"]>({ method: "POST", path: `/v1/evaluations/reviews/score-summaries`, body, options }),
+start: (id: string, body: Requests["startHumanReviewAction"], options?: RequestOptions) => transport.data<Responses["startHumanReviewAction"]>({ method: "POST", path: `/v1/evaluations/reviews/${encodeURIComponent(id)}/start`, body, options }),
+submit: (id: string, body: Requests["submitHumanReviewAction"], options?: RequestOptions) => transport.data<Responses["submitHumanReviewAction"]>({ method: "POST", path: `/v1/evaluations/reviews/${encodeURIComponent(id)}/submit`, body, options }),
+dismiss: (id: string, body: Requests["dismissHumanReviewAction"], options?: RequestOptions) => transport.data<Responses["dismissHumanReviewAction"]>({ method: "POST", path: `/v1/evaluations/reviews/${encodeURIComponent(id)}/dismiss`, body, options }) } },
+permissions: { list: (options?: RequestOptions) => transport.data<Responses["listPermissions"]>({ method: "GET", path: `/v1/permissions`, options }) },
+organizations: { roles: { list: (id: string, options?: RequestOptions) => transport.data<Responses["listOrganizationRoles"]>({ method: "GET", path: `/v1/organizations/${encodeURIComponent(id)}/roles`, options }),
+create: (id: string, body: Requests["createOrganizationRole"], options?: RequestOptions) => transport.data<Responses["createOrganizationRole"]>({ method: "POST", path: `/v1/organizations/${encodeURIComponent(id)}/roles`, body, options }),
+update: (id: string, roleId: string, body: Requests["updateOrganizationRole"], options?: RequestOptions) => transport.data<Responses["updateOrganizationRole"]>({ method: "PATCH", path: `/v1/organizations/${encodeURIComponent(id)}/roles/${encodeURIComponent(roleId)}`, body, options }),
+delete: (id: string, roleId: string, options?: RequestOptions) => transport.data<Responses["deleteOrganizationRole"]>({ method: "DELETE", path: `/v1/organizations/${encodeURIComponent(id)}/roles/${encodeURIComponent(roleId)}`, options }) },
+members: { assignRoles: (id: string, memberId: string, body: Requests["assignMemberRoles"], options?: RequestOptions) => transport.data<Responses["assignMemberRoles"]>({ method: "PATCH", path: `/v1/organizations/${encodeURIComponent(id)}/members/${encodeURIComponent(memberId)}/roles`, body, options }),
+list: (id: string, query: Queries["listOrganizationMembers"] = {}, options?: RequestOptions) => transport.data<Responses["listOrganizationMembers"]>({ method: "GET", path: `/v1/organizations/${encodeURIComponent(id)}/members`, query, options }) },
+list: (query: Queries["listOrganizations"] = {}, options?: RequestOptions) => transport.data<Responses["listOrganizations"]>({ method: "GET", path: `/v1/organizations`, query, options }),
+create: (body: Requests["createOrganization"], options?: RequestOptions) => transport.data<Responses["createOrganization"]>({ method: "POST", path: `/v1/organizations`, body, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getOrganization"]>({ method: "GET", path: `/v1/organizations/${encodeURIComponent(id)}`, options }),
+update: (id: string, body: Requests["updateOrganization"], options?: RequestOptions) => transport.data<Responses["updateOrganization"]>({ method: "PATCH", path: `/v1/organizations/${encodeURIComponent(id)}`, body, options }),
+activate: (id: string, options?: RequestOptions) => transport.data<Responses["activateOrganization"]>({ method: "POST", path: `/v1/organizations/${encodeURIComponent(id)}/activate`, options }),
+delete: (id: string, body: Requests["deleteOrganization"], options?: RequestOptions) => transport.data<Responses["deleteOrganization"]>({ method: "DELETE", path: `/v1/organizations/${encodeURIComponent(id)}`, body, options }),
+leave: (id: string, options?: RequestOptions) => transport.data<Responses["leaveOrganization"]>({ method: "POST", path: `/v1/organizations/${encodeURIComponent(id)}/leave`, options }),
+invitations: { list: (id: string, query: Queries["listInvitations"] = {}, options?: RequestOptions) => transport.data<Responses["listInvitations"]>({ method: "GET", path: `/v1/organizations/${encodeURIComponent(id)}/invitations`, query, options }),
+create: (id: string, body: Requests["inviteMember"], options?: RequestOptions) => transport.data<Responses["inviteMember"]>({ method: "POST", path: `/v1/organizations/${encodeURIComponent(id)}/invitations`, body, options }) } },
+auth: { getContext: (options?: RequestOptions) => transport.data<Responses["getAuthContext"]>({ method: "GET", path: `/v1/auth-context`, options }) },
+users: { me: (options?: RequestOptions) => transport.data<Responses["getCurrentUser"]>({ method: "GET", path: `/v1/me`, options }) },
+invitations: { cancel: (id: string, options?: RequestOptions) => transport.data<Responses["cancelInvitation"]>({ method: "POST", path: `/v1/invitations/${encodeURIComponent(id)}/cancel`, options }) },
+apiKeys: { list: (query: Queries["listApiKeys"] = {}, options?: RequestOptions) => transport.data<Responses["listApiKeys"]>({ method: "GET", path: `/v1/api-keys`, query, options }),
+create: (body: Requests["createApiKey"], options?: RequestOptions) => transport.data<Responses["createApiKey"]>({ method: "POST", path: `/v1/api-keys`, body, options }),
+revoke: (id: string, query: Queries["deleteApiKey"], options?: RequestOptions) => transport.data<Responses["deleteApiKey"]>({ method: "DELETE", path: `/v1/api-keys/${encodeURIComponent(id)}`, query, options }) },
+workspace: { resolveDefault: (options?: RequestOptions) => transport.data<Responses["resolveDefaultWorkspace"]>({ method: "POST", path: `/v1/workspaces/default`, options }),
+get: (options?: RequestOptions) => transport.data<Responses["workspaceSummary"]>({ method: "GET", path: `/v1/workspace`, options }) },
+logs: { list: (query: Queries["listLogs"] = {}, options?: RequestOptions) => transport.data<Responses["listLogs"]>({ method: "GET", path: `/v1/logs`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getLog"]>({ method: "GET", path: `/v1/logs/${encodeURIComponent(id)}`, options }) },
+traces: { list: (query: Queries["listTraces"] = {}, options?: RequestOptions) => transport.data<Responses["listTraces"]>({ method: "GET", path: `/v1/traces`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getTrace"]>({ method: "GET", path: `/v1/traces/${encodeURIComponent(id)}`, options }) },
+observability: { gatewayOverview: (options?: RequestOptions) => transport.data<Responses["gatewayOverview"]>({ method: "GET", path: `/v1/gateway/overview`, options }),
+overview: (query: Queries["observabilityOverview"] = {}, options?: RequestOptions) => transport.data<Responses["observabilityOverview"]>({ method: "GET", path: `/v1/observability/overview`, query, options }),
+metrics: (query: Queries["metrics"] = {}, options?: RequestOptions) => transport.data<Responses["metrics"]>({ method: "GET", path: `/v1/metrics`, query, options }) },
+knowledge: { search: (id: string, body: Requests["searchKnowledgeBase"], options?: RequestOptions) => transport.data<Responses["searchKnowledgeBase"]>({ method: "POST", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/search`, body, options }),
+searchStatus: (id: string, options?: RequestOptions) => transport.data<Responses["getKnowledgeSearchStatus"]>({ method: "GET", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/search-status`, options }),
+list: (query: Queries["listKnowledgeBases"] = {}, options?: RequestOptions) => transport.data<Responses["listKnowledgeBases"]>({ method: "GET", path: `/v1/knowledge-bases`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getKnowledgeBase"]>({ method: "GET", path: `/v1/knowledge-bases/${encodeURIComponent(id)}`, options }),
+create: (body: Requests["createKnowledgeBase"], options?: RequestOptions) => transport.data<Responses["createKnowledgeBase"]>({ method: "POST", path: `/v1/knowledge-bases`, body, options }),
+update: (id: string, body: Requests["updateKnowledgeBase"], options?: RequestOptions) => transport.data<Responses["updateKnowledgeBase"]>({ method: "PATCH", path: `/v1/knowledge-bases/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteKnowledgeBase"]>({ method: "DELETE", path: `/v1/knowledge-bases/${encodeURIComponent(id)}`, options }),
+documents: { list: (id: string, query: Queries["listKnowledgeDocuments"] = {}, options?: RequestOptions) => transport.data<Responses["listKnowledgeDocuments"]>({ method: "GET", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/documents`, query, options }),
+get: (id: string, documentId: string, options?: RequestOptions) => transport.data<Responses["getKnowledgeDocument"]>({ method: "GET", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/documents/${encodeURIComponent(documentId)}`, options }),
+chunks: (id: string, documentId: string, query: Queries["listKnowledgeChunks"] = {}, options?: RequestOptions) => transport.data<Responses["listKnowledgeChunks"]>({ method: "GET", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/documents/${encodeURIComponent(documentId)}/chunks`, query, options }),
+create: (id: string, body: Requests["ingestKnowledgeDocument"], options?: RequestOptions) => transport.data<Responses["ingestKnowledgeDocument"]>({ method: "POST", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/documents`, body, options }),
+update: (id: string, documentId: string, body: Requests["updateKnowledgeDocument"], options?: RequestOptions) => transport.data<Responses["updateKnowledgeDocument"]>({ method: "PATCH", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/documents/${encodeURIComponent(documentId)}`, body, options }),
+delete: (id: string, documentId: string, options?: RequestOptions) => transport.data<Responses["deleteKnowledgeDocument"]>({ method: "DELETE", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/documents/${encodeURIComponent(documentId)}`, options }),
+reindex: (id: string, documentId: string, options?: RequestOptions) => transport.data<Responses["reindexKnowledgeDocument"]>({ method: "POST", path: `/v1/knowledge-bases/${encodeURIComponent(id)}/documents/${encodeURIComponent(documentId)}/reindex`, options }) } },
+vectorStores: { list: (query: Queries["listVectorStores"] = {}, options?: RequestOptions) => transport.data<Responses["listVectorStores"]>({ method: "GET", path: `/v1/vector-stores`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getVectorStore"]>({ method: "GET", path: `/v1/vector-stores/${encodeURIComponent(id)}`, options }),
+create: (body: Requests["createVectorStore"], options?: RequestOptions) => transport.data<Responses["createVectorStore"]>({ method: "POST", path: `/v1/vector-stores`, body, options }),
+update: (id: string, body: Requests["updateVectorStore"], options?: RequestOptions) => transport.data<Responses["updateVectorStore"]>({ method: "PATCH", path: `/v1/vector-stores/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteVectorStore"]>({ method: "DELETE", path: `/v1/vector-stores/${encodeURIComponent(id)}`, options }),
+test: (id: string, options?: RequestOptions) => transport.data<Responses["testVectorStore"]>({ method: "POST", path: `/v1/vector-stores/${encodeURIComponent(id)}/test`, options }) },
+memory: { spaces: { create: (body: Requests["createMemorySpace"], options?: RequestOptions) => transport.data<Responses["createMemorySpace"]>({ method: "POST", path: `/v1/memory/spaces`, body, options }),
+list: (query: Queries["listMemorySpaces"] = {}, options?: RequestOptions) => transport.data<Responses["listMemorySpaces"]>({ method: "GET", path: `/v1/memory/spaces`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getMemorySpace"]>({ method: "GET", path: `/v1/memory/spaces/${encodeURIComponent(id)}`, options }),
+update: (id: string, body: Requests["updateMemorySpace"], options?: RequestOptions) => transport.data<Responses["updateMemorySpace"]>({ method: "PATCH", path: `/v1/memory/spaces/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteMemorySpace"]>({ method: "DELETE", path: `/v1/memory/spaces/${encodeURIComponent(id)}`, options }),
+profile: (id: string, query: Queries["getMemorySpaceProfile"] = {}, options?: RequestOptions) => transport.data<Responses["getMemorySpaceProfile"]>({ method: "GET", path: `/v1/memory/spaces/${encodeURIComponent(id)}/profile`, query, options }) },
+policies: { create: (body: Requests["createMemoryPolicy"], options?: RequestOptions) => transport.data<Responses["createMemoryPolicy"]>({ method: "POST", path: `/v1/memory/policies`, body, options }),
+list: (query: Queries["listMemoryPolicies"] = {}, options?: RequestOptions) => transport.data<Responses["listMemoryPolicies"]>({ method: "GET", path: `/v1/memory/policies`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getMemoryPolicy"]>({ method: "GET", path: `/v1/memory/policies/${encodeURIComponent(id)}`, options }),
+update: (id: string, body: Requests["updateMemoryPolicy"], options?: RequestOptions) => transport.data<Responses["updateMemoryPolicy"]>({ method: "PATCH", path: `/v1/memory/policies/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteMemoryPolicy"]>({ method: "DELETE", path: `/v1/memory/policies/${encodeURIComponent(id)}`, options }) },
+items: { list: (query: Queries["listMemoryItems"] = {}, options?: RequestOptions) => transport.data<Responses["listMemoryItems"]>({ method: "GET", path: `/v1/memory/items`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getMemoryItem"]>({ method: "GET", path: `/v1/memory/items/${encodeURIComponent(id)}`, options }),
+update: (id: string, body: Requests["updateMemoryItem"], options?: RequestOptions) => transport.data<Responses["updateMemoryItem"]>({ method: "PATCH", path: `/v1/memory/items/${encodeURIComponent(id)}`, body, options }),
+delete: (id: string, options?: RequestOptions) => transport.data<Responses["deleteMemoryItem"]>({ method: "DELETE", path: `/v1/memory/items/${encodeURIComponent(id)}`, options }),
+evidence: (id: string, query: Queries["listMemoryItemEvidence"] = {}, options?: RequestOptions) => transport.data<Responses["listMemoryItemEvidence"]>({ method: "GET", path: `/v1/memory/items/${encodeURIComponent(id)}/evidence`, query, options }),
+relations: (id: string, query: Queries["listMemoryItemRelations"] = {}, options?: RequestOptions) => transport.data<Responses["listMemoryItemRelations"]>({ method: "GET", path: `/v1/memory/items/${encodeURIComponent(id)}/relations`, query, options }),
+embeddings: (id: string, query: Queries["listMemoryItemEmbeddings"] = {}, options?: RequestOptions) => transport.data<Responses["listMemoryItemEmbeddings"]>({ method: "GET", path: `/v1/memory/items/${encodeURIComponent(id)}/embeddings`, query, options }),
+entities: (id: string, query: Queries["listMemoryItemEntities"] = {}, options?: RequestOptions) => transport.data<Responses["listMemoryItemEntities"]>({ method: "GET", path: `/v1/memory/items/${encodeURIComponent(id)}/entities`, query, options }) },
+runs: { list: (query: Queries["listMemoryRuns"] = {}, options?: RequestOptions) => transport.data<Responses["listMemoryRuns"]>({ method: "GET", path: `/v1/memory/runs`, query, options }),
+get: (id: string, options?: RequestOptions) => transport.data<Responses["getMemoryRun"]>({ method: "GET", path: `/v1/memory/runs/${encodeURIComponent(id)}`, options }) } } }; }
+export type ManagementResources = ReturnType<typeof managementResources>;

package/src/memory/memory.ts

@@ -0,0 +1,108 @@
+import type { HttpTransport } from "../core/transport.js";
+import type { RequestOptions } from "../core/types.js";
+import type { ManagementResources } from "../management/resources.js";
+import type * as T from "./types.js";
+
+/** One public domain; transports remain a client composition detail. */
+export class Memory {
+  readonly spaces: ManagementResources["memory"]["spaces"];
+  readonly policies: ManagementResources["memory"]["policies"];
+  readonly items: ManagementResources["memory"]["items"] & {
+    create: (
+      body: T.MemoryManualRequest,
+      options?: RequestOptions,
+    ) => Promise<T.MemoryIngestResponse>;
+  };
+  readonly runs: ManagementResources["memory"]["runs"];
+  readonly profiles: {
+    get: ManagementResources["memory"]["spaces"]["profile"];
+    generate: (
+      body: T.MemoryGenerateRequest,
+      options?: RequestOptions,
+    ) => Promise<T.MemoryProfileGenerateResponse>;
+  };
+  readonly observations: {
+    generate: (
+      body: T.MemoryGenerateRequest,
+      options?: RequestOptions,
+    ) => Promise<T.MemoryObservationGenerateResponse>;
+  };
+  constructor(
+    management: ManagementResources["memory"],
+    private readonly runtime: HttpTransport,
+  ) {
+    this.spaces = management.spaces;
+    this.policies = management.policies;
+    this.runs = management.runs;
+    this.items = {
+      ...management.items,
+      create: (body, options) => this.command("items", body, options),
+    };
+    this.profiles = {
+      get: management.spaces.profile,
+      generate: (body, options) =>
+        this.command("profiles/generate", body, options),
+    };
+    this.observations = {
+      generate: (body, options) =>
+        this.command("observations/generate", body, options),
+    };
+  }
+  private command<R>(
+    path: string,
+    body: unknown,
+    options?: RequestOptions,
+  ): Promise<R> {
+    const replayable = path === "ingest" || path === "items";
+    const input =
+      replayable && options?.idempotencyKey && body && typeof body === "object"
+        ? {
+            ...body,
+            idempotencyKey:
+              (body as { idempotencyKey?: string }).idempotencyKey ??
+              options.idempotencyKey,
+          }
+        : body;
+    return this.runtime.data<R>({
+      method: "POST",
+      path: `/v1/memory/${path}`,
+      body: input,
+      options: replayable ? options : { ...options, maxRetries: 0 },
+    });
+  }
+  ingest(
+    body: T.MemoryIngestRequest,
+    options?: RequestOptions,
+  ): Promise<T.MemoryIngestResponse> {
+    return this.command("ingest", body, options);
+  }
+  search(
+    body: T.MemorySearchRequest,
+    options?: RequestOptions,
+  ): Promise<T.MemorySearchResponse> {
+    return this.command("search", body, options);
+  }
+  context(
+    body: T.MemoryContextRequest,
+    options?: RequestOptions,
+  ): Promise<T.MemoryContextResponse> {
+    return this.command("context", body, options);
+  }
+  reindex(
+    body: T.MemoryReindexRequest,
+    options?: RequestOptions,
+  ): Promise<T.MemoryIndexingResult & { memoryRunId: string }> {
+    return this.command("reindex", body, options);
+  }
+  /** Requires a space tombstoned through spaces.delete; backend owns cleanup. */
+  erase(
+    spaceId: string,
+    options?: RequestOptions,
+  ): Promise<{ id: string; erased: boolean }> {
+    return this.runtime.data({
+      method: "DELETE",
+      path: `/v1/memory/spaces/${encodeURIComponent(spaceId)}/erase`,
+      options,
+    });
+  }
+}

package/src/memory/types.ts

@@ -0,0 +1,157 @@
+import type { Requests, Queries, Responses } from "../management/contracts.js";
+import type { JsonValue } from "../core/types.js";
+
+export interface MemoryPage<T> {
+  items: T[];
+  nextCursor: string | null;
+}
+export type MemorySpace = Responses["getMemorySpace"];
+export type MemoryPolicy = Responses["getMemoryPolicy"];
+export type MemoryItem = Responses["getMemoryItem"];
+export type MemoryEvidence =
+  Responses["listMemoryItemEvidence"]["items"][number];
+export type MemoryRelation =
+  Responses["listMemoryItemRelations"]["items"][number];
+export type MemoryEmbedding =
+  Responses["listMemoryItemEmbeddings"]["items"][number];
+export type MemoryItemEntity =
+  Responses["listMemoryItemEntities"]["items"][number];
+export type MemoryEntity = MemoryItemEntity["entity"];
+export type MemoryProfile = Responses["getMemorySpaceProfile"];
+export type MemoryRun = Responses["getMemoryRun"];
+export type MemorySpaceCreate = Requests["createMemorySpace"];
+export type MemorySpaceUpdate = Requests["updateMemorySpace"];
+export type MemoryPolicyCreate = Requests["createMemoryPolicy"];
+export type MemoryPolicyUpdate = Requests["updateMemoryPolicy"];
+export type MemoryItemUpdate = Requests["updateMemoryItem"];
+export type MemorySpaceFilters = Queries["listMemorySpaces"];
+export type MemoryPolicyFilters = Queries["listMemoryPolicies"];
+export type MemoryItemFilters = Queries["listMemoryItems"];
+export type MemoryRunFilters = Queries["listMemoryRuns"];
+export type MemoryType = NonNullable<MemoryItemFilters["type"]>;
+export type MemoryStatus = NonNullable<MemoryItemFilters["status"]>;
+export type MemoryLayer = NonNullable<MemoryItemFilters["layer"]>;
+export type MemorySourceType =
+  | "chat_message"
+  | "conversation"
+  | "api"
+  | "tool"
+  | "event"
+  | "document"
+  | "manual"
+  | "system"
+  | "other";
+export interface MemoryMessage {
+  id?: string;
+  role: "user" | "assistant" | "tool" | "system" | "developer";
+  content: string;
+  createdAt?: string;
+}
+export interface MemoryEvent {
+  sourceType: MemorySourceType;
+  externalSourceId?: string;
+  content: string;
+  occurredAt?: string;
+  actorType?: string;
+  actorId?: string;
+  sourceUri?: string;
+  metadata?: JsonValue;
+}
+export interface MemoryIngestRequest {
+  memorySpaceId: string;
+  conversationId?: string;
+  sessionId?: string;
+  messages?: MemoryMessage[];
+  events?: MemoryEvent[];
+  context?: MemoryMessage[];
+  metadata?: JsonValue;
+  idempotencyKey?: string;
+}
+export interface MemorySearchFilters {
+  types?: MemoryType[];
+  layers?: MemoryLayer[];
+  activeOnly?: boolean;
+  validAt?: string;
+  entityId?: string;
+  containsPII?: boolean;
+  sensitivities?: NonNullable<MemoryItemUpdate["sensitivity"]>[];
+}
+export interface MemorySearchRequest {
+  memorySpaceId: string;
+  query: string;
+  limit?: number;
+  filters?: MemorySearchFilters;
+}
+export interface MemoryContextRequest extends Omit<
+  MemorySearchRequest,
+  "query"
+> {
+  messages: Array<Pick<MemoryMessage, "role" | "content">>;
+}
+export type MemoryResult = Pick<
+  MemoryItem,
+  | "id"
+  | "content"
+  | "type"
+  | "layer"
+  | "status"
+  | "validFrom"
+  | "validUntil"
+  | "confidence"
+>;
+export interface MemorySearchResponse {
+  memories: Array<MemoryResult & { score: number }>;
+}
+export interface MemoryContextResponse {
+  memories: Array<MemoryResult & { score?: number }>;
+}
+export interface MemoryIndexingResult {
+  indexed: number;
+  failed: number;
+}
+export interface MemoryIngestResponse {
+  memoryRunId: string;
+  memories: MemoryResult[];
+  candidateCount: number;
+  acceptedCount: number;
+  rejectedCount: number;
+  insertedCount: number;
+  mergedCount: number;
+  reinforcedCount: number;
+  supersededCount: number;
+  ignoredCount: number;
+  indexing: MemoryIndexingResult;
+  replayed?: boolean;
+}
+export interface MemoryManualRequest {
+  memorySpaceId: string;
+  content: string;
+  type?: MemoryType;
+  canonicalKey?: string;
+  idempotencyKey?: string;
+  validFrom?: string;
+}
+export interface MemoryIndexingConfig {
+  model: string;
+  dimensions: number;
+  /** Optional organization-owned override. Omit to use Nirmos-managed storage. */
+  vectorStoreConnectionId?: string | null;
+  distanceMetric?: "cosine" | "dot" | "euclid";
+}
+export interface MemoryReindexRequest {
+  memorySpaceId: string;
+  memoryIds?: string[];
+  indexing?: MemoryIndexingConfig;
+}
+export interface MemoryGenerateRequest {
+  memorySpaceId: string;
+}
+export interface MemoryProfileGenerateResponse {
+  memoryRunId: string;
+  profile: MemoryProfile;
+}
+export interface MemoryObservationGenerateResponse {
+  memoryRunId: string;
+  observations: Array<Pick<MemoryItem, "id" | "content" | "type" | "layer">>;
+  indexing: MemoryIndexingResult;
+}

package/src/prompts/render.ts

@@ -9,7 +9,7 @@ import type {
   RenderedPrompt,
 } from "./types.js";
 
-const PLACEHOLDER = /\{\{\s*([a-zA-Z][a-zA-Z0-9_.-]*)\s*\}\}/g;
+import { PROMPT_VARIABLE_PATTERN as PLACEHOLDER, promptVariableValue, validatePromptTemplate, validatePromptVariableValues } from "./variables.js";
 
 export function renderPrompt(
   prompt: Prompt,
@@ -65,7 +65,8 @@ function resolveVariables(
   const missing: string[] = [];
 
   for (const variable of definitions) {
-    const value = resolved[variable.name];
+    const value = promptVariableValue(resolved, variable.name);
+    if (value !== undefined) resolved[variable.name] = value as JsonValue;
     if (value === undefined && variable.default !== undefined) {
       resolved[variable.name] = variable.default;
     } else if (value === undefined && variable.required) {
@@ -79,6 +80,8 @@ function resolveVariables(
       missing,
     );
   }
+  const errors = validatePromptVariableValues(definitions, resolved);
+  if (Object.keys(errors).length) throw new PromptRenderError(Object.entries(errors).map(([name, error]) => `${name}: ${error}`).join(" "), Object.keys(errors));
   return resolved;
 }
 
@@ -87,14 +90,16 @@ function interpolate(
   values: PromptVariableValues,
   options: PromptRenderOptions,
 ): string {
+  const syntaxErrors = validatePromptTemplate(template);
+  if (syntaxErrors.length) throw new PromptRenderError(syntaxErrors.join(" "), []);
   const unresolved = new Set<string>();
   const result = template.replace(PLACEHOLDER, (placeholder, name: string) => {
-    const value = values[name];
+    const value = promptVariableValue(values, name);
     if (value === undefined) {
       unresolved.add(name);
       return placeholder;
     }
-    return stringify(value);
+    return stringify(value as JsonValue);
   });
 
   if (unresolved.size > 0 && !options.allowUnresolved) {