@w6w/embed 0.2.1 → 0.2.11

package/dist/repos/credentials.d.ts

@@ -0,0 +1,83 @@
+import { QueryClient } from '@tanstack/react-query';
+import { W6WClient } from '@w6w/sdk';
+import { CredentialDependents, CredentialListFilter, CredentialSummary, CredentialTestResult } from '@w6w/sdk/console';
+export type { CredentialDependents, CredentialListFilter, CredentialSummary, CredentialTestResult, } from '@w6w/sdk/console';
+export declare const credentialsKey: readonly ["credentials"];
+export declare const credentialKey: (id: string) => readonly ["credential", string];
+export declare const credentialDependentsKey: (id: string) => readonly ["credential-dependents", string];
+/**
+ * A credential write (rotate, enable/disable, delete) changes what every connection on it
+ * reports, so the credential keys AND every cached connection (single and per-app) go stale.
+ */
+export declare function invalidateAfterCredentialWrite(qc: QueryClient, id: string): void;
+export declare function listCredentials(client: W6WClient, filter?: CredentialListFilter): Promise<CredentialSummary[]>;
+export declare function getCredential(client: W6WClient, id: string): Promise<CredentialSummary>;
+export declare function createCredential(client: W6WClient, body: {
+    name: string;
+    contract: string;
+    source: Record<string, unknown>;
+}): Promise<CredentialSummary>;
+/** Rename. */
+export declare function updateCredential(client: W6WClient, id: string, body: {
+    name: string;
+}): Promise<CredentialSummary>;
+export declare function rotateCredential(client: W6WClient, id: string, body: {
+    source: Record<string, unknown>;
+}): Promise<CredentialSummary>;
+export declare function setCredentialStatus(client: W6WClient, id: string, status: "active" | "disabled"): Promise<CredentialSummary>;
+export declare function testCredential(client: W6WClient, id: string): Promise<CredentialTestResult>;
+export declare function getCredentialDependents(client: W6WClient, id: string): Promise<CredentialDependents>;
+export type DeleteCredentialResult = {
+    ok: true;
+} | {
+    ok: false;
+    dependents: CredentialDependents;
+};
+/**
+ * Delete. A 409 `credential_in_use` is data — `{ ok: false, dependents }` — not a thrown error;
+ * every other failure rejects. There is no `force`: a credential in use is never deleted.
+ * Wire (RECONCILE R-11): `{ error: { code, message, dependents: { connections } } }`.
+ */
+export declare function deleteCredential(client: W6WClient, id: string): Promise<DeleteCredentialResult>;
+export declare function useCredentialsQuery(filter?: CredentialListFilter): import('@tanstack/react-query').UseQueryResult<NoInfer<CredentialSummary[]>, Error>;
+export declare function useCredentialQuery(id: string): import('@tanstack/react-query').UseQueryResult<NoInfer<CredentialSummary>, Error>;
+export declare function useCredentialDependentsQuery(id: string, enabled?: boolean): import('@tanstack/react-query').UseQueryResult<NoInfer<CredentialDependents>, Error>;
+export declare function useCreateCredentialMutation(): import('@tanstack/react-query').UseMutationResult<CredentialSummary, Error, {
+    name: string;
+    contract: string;
+    source: Record<string, unknown>;
+}, unknown>;
+/** Rename touches only the credential keys: no connection's state changes. */
+export declare function useUpdateCredentialMutation(id: string): import('@tanstack/react-query').UseMutationResult<CredentialSummary, Error, {
+    name: string;
+}, unknown>;
+export declare function useRotateCredentialMutation(id: string): import('@tanstack/react-query').UseMutationResult<CredentialSummary, Error, {
+    source: Record<string, unknown>;
+}, unknown>;
+export declare function useSetCredentialStatusMutation(id: string): import('@tanstack/react-query').UseMutationResult<CredentialSummary, Error, "active" | "disabled", unknown>;
+export declare function useTestCredentialMutation(id: string): import('@tanstack/react-query').UseMutationResult<CredentialTestResult, Error, void, unknown>;
+export declare function useDeleteCredentialMutation(): import('@tanstack/react-query').UseMutationResult<DeleteCredentialResult, Error, string, unknown>;
+/**
+ * The eight optional `W6WApi` credential methods over `client` (this module may not import
+ * `@w6w/ui`, so the signatures are checked where they are spread into a `W6WApi`: Studio's
+ * facade, and `W6WEmbedProvider`'s bridge). `deleteCredential` rejects on a
+ * 409 with the response body attached as `.body` (as `withApiErrorBody` does in the react adapter).
+ */
+export declare function credentialUiMethods(client: W6WClient): {
+    listCredentials: (filter?: CredentialListFilter) => Promise<CredentialSummary[]>;
+    createCredential: (body: {
+        name: string;
+        contract: string;
+        source: Record<string, unknown>;
+    }) => Promise<CredentialSummary>;
+    getCredential: (id: string) => Promise<CredentialSummary>;
+    rotateCredential: (id: string, body: {
+        source: Record<string, unknown>;
+    }) => Promise<CredentialSummary>;
+    setCredentialStatus: (id: string, status: "active" | "disabled") => Promise<CredentialSummary>;
+    testCredential: (id: string) => Promise<CredentialTestResult>;
+    credentialDependents: (id: string) => Promise<CredentialDependents>;
+    deleteCredential: (id: string) => Promise<void>;
+};
+/** Fills ONLY the credential methods that are not functions on `adapter`; keeps the rest. */
+export declare function withCredentialMethods<T extends object>(adapter: T, client: W6WClient): T;

package/dist/repos/endpoints.d.ts

@@ -1,5 +1,5 @@
 import { W6WClient } from '@w6w/sdk';
-import { EndpointDef as SdkEndpointDef, EndpointSummary as SdkEndpointSummary, EndpointTarget as SdkEndpointTarget } from '@w6w/sdk/console';
+import { EndpointInvokeResult, EndpointDef as SdkEndpointDef, EndpointSummary as SdkEndpointSummary, EndpointTarget as SdkEndpointTarget } from '@w6w/sdk/console';
 export type { ActionTarget, CallableRef, CallableOnError, ErrorHandlerTarget, EndpointAuthMode, EndpointInput, EndpointInvokeResult, EndpointSecurity, EndpointTarget, ErrorReroute, Exposure, RetryPolicy, } from '@w6w/sdk/console';
 export { SECRET_MASK } from '@w6w/sdk/console';
 /** An Endpoint's OWN target: the alias-only `endpoint` arm excluded, mirroring the
@@ -108,8 +108,14 @@ export declare function useGuardedSaveEndpointMutation(): import('@tanstack/reac
     definition: unknown;
     ifUnmodifiedSince: string | null;
 }, unknown>;
-export declare function invokeEndpoint(client: W6WClient, id: string, input: Record<string, unknown>): Promise<import('@w6w/sdk/console').EndpointInvokeResult>;
-export declare function useInvokeEndpointMutation(): import('@tanstack/react-query').UseMutationResult<import('@w6w/sdk/console').EndpointInvokeResult, Error, {
+/**
+ * `POST /endpoints/:id/invoke` through `client.request` (D2). Answers `{ kind, output }`, or a 202
+ * `{ kind: "workflow", runId }` (success). `allowUnpublished: true` only when the caller opts in.
+ */
+export declare function invokeEndpoint(client: W6WClient, id: string, input: Record<string, unknown>, opts?: {
+    allowUnpublished?: boolean;
+}): Promise<EndpointInvokeResult>;
+export declare function useInvokeEndpointMutation(): import('@tanstack/react-query').UseMutationResult<EndpointInvokeResult, Error, {
     id: string;
     input: Record<string, unknown>;
 }, unknown>;

package/dist/repos/fields.d.ts

@@ -0,0 +1,34 @@
+import { W6WClient } from '@w6w/sdk';
+/**
+ * Dynamic-field resolution — `POST /apps/:id/actions/:key/fields` over `client.request()`.
+ * A 424 (the vendor lookup failed) becomes a per-field error result so one bad lookup does not
+ * blank the form; every other failure (400/403/404/network/abort) rethrows for the ui to handle.
+ */
+/**
+ * Structural mirror of ui's `W6WApi.resolveActionFields` shapes (this barrel may not import
+ * `@w6w/ui`); the facade/UiBridge assignment typechecks against W6WApi structurally.
+ */
+export interface ResolveActionFieldsBody {
+    connectionId: string;
+    version?: string;
+    reason: "init" | "change";
+    form: Record<string, unknown>;
+    previous?: Record<string, unknown>;
+    changed?: string[];
+    fields: string[];
+    unresolved: string[];
+}
+export interface ResolveActionFieldsResult {
+    fields: Record<string, {
+        options?: {
+            value: string | number;
+            label: string;
+            description?: string;
+        }[];
+        error?: string;
+    }>;
+}
+export interface ResolveActionFieldsOpts {
+    signal?: AbortSignal;
+}
+export declare function resolveActionFields(client: W6WClient, appId: string, actionKey: string, body: ResolveActionFieldsBody, opts?: ResolveActionFieldsOpts): Promise<ResolveActionFieldsResult>;

package/dist/repos/functions.d.ts

@@ -58,12 +58,14 @@ export interface FunctionInvokeResult {
     durationMs?: number;
 }
 /**
- * `fn_…` ids are already URN-shaped, so the base dispatcher resolves them
- * directly — no id translation. `isFunctionRun` narrows the open
- * `RunEnvelope`; a `fn_…` URN can only ever resolve to the `function` arm
- * server-side, so the `else` branch is defensive, not a real code path.
+ * `POST /functions/:id/invoke` through the `client.request` escape hatch (D2: no wrappers change).
+ * The route answers the invocation frame `{ kind: "function", output, invocationId, status,
+ * durationMs }`. `allowUnpublished: true` is sent ONLY when the caller opts in (the editor's Test
+ * invoke hook); every other caller keeps the publish gate, so the key is absent otherwise.
  */
-export declare function invokeFunction(client: W6WClient, id: string, inputs: Record<string, unknown>): Promise<FunctionInvokeResult>;
+export declare function invokeFunction(client: W6WClient, id: string, inputs: Record<string, unknown>, opts?: {
+    allowUnpublished?: boolean;
+}): Promise<FunctionInvokeResult>;
 export declare function useInvokeFunctionMutation(): import('@tanstack/react-query').UseMutationResult<FunctionInvokeResult, Error, {
     id: string;
     inputs: Record<string, unknown>;

package/dist/repos/index.d.ts

@@ -26,7 +26,12 @@ export * from './endpoints.ts';
 export * from './spec-export.ts';
 export * from './apps.ts';
 export * from './connections.ts';
+export * from './credentials.ts';
 export * from './saved-tests.ts';
 export * from './reliability.ts';
 export * from './dashboard.ts';
 export * from './api-calls.ts';
+export * from './models.ts';
+export * from './agents-studio-agents.ts';
+export * from './agents-studio-assets.ts';
+export * from './fields.ts';

package/dist/repos/models.d.ts

@@ -0,0 +1,289 @@
+import { W6WClient } from '@w6w/sdk';
+export interface ModelRates {
+    input?: number;
+    output?: number;
+    cachedInput?: number;
+    cacheWrite?: number;
+    perRequest?: number;
+    currency?: string;
+}
+export interface ModelRate {
+    id: string;
+    modelId: string;
+    effectiveFrom: string;
+    rates: ModelRates;
+    source: "seed" | "tenant";
+}
+export interface Model {
+    id: string;
+    providerAppId: string;
+    provider: string;
+    nativeId: string;
+    displayName: string;
+    capabilities: unknown;
+    limits: {
+        maxInputTokens?: number;
+        maxOutputTokens?: number;
+    };
+    status: "active" | "deprecated" | "blocked";
+    source: "discovered" | "manual";
+    currentRate: ModelRate | null;
+    discoveredAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ModelFallback {
+    model: string;
+    connection: string;
+}
+export interface ModelRoute {
+    id: string;
+    name: string;
+    project: string;
+    modelId: string;
+    connectionId: string;
+    fallbacks: ModelFallback[];
+    defaults: Record<string, unknown>;
+    status: "active" | "broken";
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ModelRouteInput {
+    name: string;
+    model: string;
+    connection: string;
+    fallbacks?: ModelFallback[];
+    defaults?: Record<string, unknown>;
+}
+export type ModelRoutePatch = Partial<Omit<ModelRouteInput, "name">>;
+export interface ModelBudgetLimits {
+    requests?: number;
+    tokens?: number;
+    costMinor?: number;
+    currency?: string;
+}
+export interface ModelBudget {
+    id: string;
+    scopeKind: string;
+    scopeId: string | null;
+    window: string;
+    limits: ModelBudgetLimits;
+    onBreach: "block" | "warn";
+}
+export interface ModelBudgetInput {
+    scopeKind: string;
+    scopeId?: string;
+    window: string;
+    limits: ModelBudgetLimits;
+    onBreach: "block" | "warn";
+}
+export type ModelBudgetPatch = Partial<Omit<ModelBudgetInput, "scopeKind" | "scopeId">>;
+export interface ModelBudgetUsageCounts {
+    requests: number;
+    tokens: number;
+    costMinor: number;
+}
+export interface ModelBudgetUsage {
+    budgetId: string;
+    window: string;
+    windowStart: string;
+    limits: ModelBudgetLimits;
+    used: ModelBudgetUsageCounts;
+    reserved: ModelBudgetUsageCounts;
+}
+export interface ModelCost {
+    currency: string;
+    amountMinor: number;
+}
+export interface ModelUsageGroup {
+    key: string;
+    requests: number;
+    totalTokens: number;
+    cost: ModelCost[];
+}
+export interface ModelUsageTotals {
+    requests: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+    cost: ModelCost[];
+    unpriced: number;
+}
+export interface ModelUsageItem {
+    id: string;
+    routeId: string | null;
+    modelId: string;
+    connectionId: string;
+    provider: string;
+    nativeId: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+    costMinor: number | null;
+    currency: string | null;
+    rateVersion: string | null;
+    durationMs: number;
+    ok: boolean;
+    errorCode: string | null;
+    invocationId: string | null;
+    runId: string | null;
+    occurredAt: string;
+}
+export interface ModelUsageReport {
+    totals: ModelUsageTotals;
+    totalsTruncated?: boolean | null;
+    groups?: ModelUsageGroup[];
+    items: ModelUsageItem[];
+    nextCursor: string | null;
+}
+export interface ModelUsageFilter {
+    route?: string;
+    model?: string;
+    from?: string;
+    to?: string;
+    groupBy?: "route" | "model" | "day";
+    limit?: number;
+    cursor?: string;
+}
+export interface ModelCatalogFilter {
+    provider?: string;
+    status?: string;
+    limit?: number;
+    cursor?: string;
+}
+export interface ModelCatalogPage {
+    models: Model[];
+    nextCursor: string | null;
+}
+export declare const modelCatalogKey: (filter?: ModelCatalogFilter) => readonly ["model-catalog", ModelCatalogFilter];
+export declare const modelProvidersKey: readonly ["model-providers"];
+export declare const modelRoutesKey: (projectId?: string) => readonly ["model-routes", string | undefined];
+export declare const modelBudgetsKey: (projectId?: string) => readonly ["model-budgets", string | undefined];
+export declare const modelBudgetUsageKey: (id: string, projectId?: string) => readonly ["model-budget-usage", string, string | undefined];
+export declare const modelUsageKey: (projectId?: string, filter?: ModelUsageFilter) => readonly ["model-usage", string | undefined, ModelUsageFilter];
+export declare function listModelCatalog(client: W6WClient, filter?: ModelCatalogFilter): Promise<ModelCatalogPage>;
+/** One row of `GET /models/providers` — the descriptor the model pickers are driven by. */
+export interface ModelProviderRow {
+    appId: string;
+    provider: string | null;
+    installed: boolean;
+    designation?: {
+        modelTypes: string[];
+        modelFamilies?: string[];
+    } | null;
+    operations?: {
+        discover: {
+            supported: boolean;
+            reason?: string;
+        };
+        complete: {
+            supported: boolean;
+            reason?: string;
+            features?: Partial<Record<ModelFeature, ModelFeatureState>>;
+        };
+    };
+    /** A2 (optional): the bridge adapter serving this app; `null` = none. */
+    adapter?: {
+        provider: string;
+        contractVersion: number;
+    } | null;
+    /** A2 (optional): why this app cannot serve the caller right now. */
+    reasons?: ModelProviderReason[];
+}
+export type ModelFeature = "toolCalls" | "structuredOutput" | "streaming";
+export type ModelFeatureState = "supported" | "unsupported" | "unknown";
+export type ModelProviderReasonCode = "not_installed" | "no_adapter" | "not_entitled" | "no_connection";
+export interface ModelProviderReason {
+    code: ModelProviderReasonCode;
+    message: string;
+}
+export interface CompleteSupport {
+    supported: boolean;
+    features: Partial<Record<ModelFeature, ModelFeatureState>>;
+    reasons: ModelProviderReason[];
+}
+/**
+ * THE support policy for `operations.complete`. Unsupported when the descriptor says so or the
+ * row names no adapter (`adapter: null`); a pre-A2 row (no `adapter`/`features`/`reasons`) falls
+ * back to `operations.complete.supported`. Unsupported rows always carry a reason.
+ */
+export declare function completeSupport(row: ModelProviderRow): CompleteSupport;
+/** Follow `nextCursor` until null (or `maxPages`), concatenating `models`. */
+export declare function loadAllModelCatalogPages(fetchPage: (cursor?: string) => Promise<ModelCatalogPage>, opts?: {
+    maxPages?: number;
+}): Promise<{
+    models: Model[];
+    truncated: boolean;
+}>;
+export type ModelOperation = "discover" | "complete";
+export interface ConnectionChoice {
+    id: string;
+    appId: string;
+    displayName: string;
+    /** Present only when the descriptor says the operation is unsupported for this provider. */
+    disabledReason?: string;
+}
+export declare function listModelProviders(client: W6WClient): Promise<ModelProviderRow[]>;
+/**
+ * The connections a model picker may offer for `operation`, decided by the descriptor alone:
+ * a connection whose app has no designated provider row never appears (an `ai`-category app is
+ * not a provider); a designated row whose `discover` is unsupported appears disabled with the
+ * descriptor's reason; for `complete` the shared `completeSupport` policy decides (unsupported => disabled, never selectable).
+ */
+export declare function connectionChoices<C extends {
+    id: string;
+    appId: string;
+    displayName: string;
+}>(connections: C[], providers: ModelProviderRow[], operation: ModelOperation): ConnectionChoice[];
+/** The server answers fallbacks as `{modelId, connectionId}`; the editor works in `{model, connection}`. */
+export declare function normaliseRoute(r: ModelRoute): ModelRoute;
+export declare function listModelRoutes(client: W6WClient, project: string): Promise<ModelRoute[]>;
+export declare function createModelRoute(client: W6WClient, project: string, input: ModelRouteInput): Promise<ModelRoute>;
+export declare function updateModelRoute(client: W6WClient, project: string, name: string, patch: ModelRoutePatch): Promise<ModelRoute>;
+export declare function deleteModelRoute(client: W6WClient, project: string, name: string): Promise<void>;
+export declare function listModelBudgets(client: W6WClient, project: string): Promise<ModelBudget[]>;
+export declare function createModelBudget(client: W6WClient, project: string, input: ModelBudgetInput): Promise<ModelBudget>;
+export declare function updateModelBudget(client: W6WClient, project: string, id: string, patch: ModelBudgetPatch): Promise<ModelBudget>;
+export declare function deleteModelBudget(client: W6WClient, project: string, id: string): Promise<void>;
+export declare function getModelBudgetUsage(client: W6WClient, project: string, id: string): Promise<ModelBudgetUsage>;
+export declare function getModelUsage(client: W6WClient, project: string, filter?: ModelUsageFilter): Promise<ModelUsageReport>;
+export declare function useModelCatalogQuery(filter?: ModelCatalogFilter): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelCatalogPage>, Error>;
+export declare function useAllModelCatalogQuery(filter?: Omit<ModelCatalogFilter, "cursor">): import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    models: Model[];
+    truncated: boolean;
+}>, Error>;
+export declare function useModelProvidersQuery(): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelProviderRow[]>, Error>;
+export declare function useModelRoutesQuery(projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelRoute[]>, Error>;
+export declare function useModelBudgetsQuery(projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelBudget[]>, Error>;
+export declare function useModelBudgetUsageQuery(id: string, projectId?: string): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelBudgetUsage>, Error>;
+export declare function useModelUsageQuery(projectId?: string, filter?: ModelUsageFilter): import('@tanstack/react-query').UseQueryResult<NoInfer<ModelUsageReport>, Error>;
+export declare function useCreateModelRouteMutation(): import('@tanstack/react-query').UseMutationResult<ModelRoute, Error, {
+    project: string;
+    input: ModelRouteInput;
+}, unknown>;
+export declare function useUpdateModelRouteMutation(): import('@tanstack/react-query').UseMutationResult<ModelRoute, Error, {
+    project: string;
+    name: string;
+    patch: ModelRoutePatch;
+}, unknown>;
+export declare function useDeleteModelRouteMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    project: string;
+    name: string;
+}, unknown>;
+export declare function useCreateModelBudgetMutation(): import('@tanstack/react-query').UseMutationResult<ModelBudget, Error, {
+    project: string;
+    input: ModelBudgetInput;
+}, unknown>;
+export declare function useUpdateModelBudgetMutation(): import('@tanstack/react-query').UseMutationResult<ModelBudget, Error, {
+    project: string;
+    id: string;
+    patch: ModelBudgetPatch;
+}, unknown>;
+export declare function useDeleteModelBudgetMutation(): import('@tanstack/react-query').UseMutationResult<void, Error, {
+    project: string;
+    id: string;
+}, unknown>;