@ziggs-ai/api-client 0.1.6 → 0.1.8

package/dist/http/ChatClient.d.ts

@@ -26,9 +26,38 @@ export interface SendChatMessageResult {
     messageId: string;
     chatId: string;
 }
+export type ContextTemporal = 'from-now' | 'from-start';
+export interface AddChatMemberInput {
+    chatId: string;
+    memberId: string;
+    memberType: 'user' | 'agent';
+    temporal?: ContextTemporal;
+}
+export interface ChatPendingAdmission {
+    admissionId: string;
+    agentId: string;
+    issuerId: string;
+    invitedBy: 'user' | 'agent';
+    temporal: ContextTemporal;
+    status: 'pending' | 'approved' | 'rejected';
+    approvals?: unknown[];
+    createdAt?: string;
+}
+export type AddChatMemberResult = {
+    status: 'pending';
+    pendingAdmission: ChatPendingAdmission;
+} | {
+    status: 'approved';
+    chat?: unknown;
+} | {
+    chat?: unknown;
+};
+/**
+ * POST /chats/:chatId/members — add user/agent; agent-invite may return pending admission (ZIG-426).
+ */
+export declare function addChatMember(input: AddChatMemberInput, creds: Creds): Promise<AddChatMemberResult>;
 /**
  * POST /chats/:chatId/messages as an impersonated delegate agent.
- * Requires operator token + X-Agent-Id (ZIG-222).
  */
 export declare function sendChatMessage(input: SendChatMessageInput, creds: Creds): Promise<SendChatMessageResult>;
 export declare function listMyChats(creds: Creds): Promise<ChatSummary[]>;

package/dist/http/ChatClient.js

@@ -32,7 +32,6 @@ export async function openConversation(participantId, creds) {
     if (!participantId)
         throw new Error('participantId is required for openConversation');
     assertCreds(creds, 'open conversation');
-    // Canonical REST: POST /chats with { participantId }, returns { chatId }.
     const res = await fetch(`${getBackendUrl()}/chats`, {
         method: 'POST',
         headers: buildHeaders(creds),
@@ -48,9 +47,39 @@ export async function openConversation(participantId, creds) {
     }
     return { chatId: data['chatId'] };
 }
+/**
+ * POST /chats/:chatId/members — add user/agent; agent-invite may return pending admission (ZIG-426).
+ */
+export async function addChatMember(input, creds) {
+    assertCreds(creds, 'add chat member');
+    const res = await fetch(`${getBackendUrl()}/chats/${encodeURIComponent(input.chatId)}/members`, {
+        method: 'POST',
+        headers: buildHeaders(creds),
+        body: JSON.stringify({
+            chatId: input.chatId,
+            memberId: input.memberId,
+            memberType: input.memberType,
+            temporal: input.temporal,
+        }),
+    });
+    const body = await res.text().catch(() => '');
+    if (!res.ok) {
+        throwApiError(res, body, `addChatMember failed: ${res.status} ${res.statusText}`);
+    }
+    const data = JSON.parse(body);
+    if (data['status'] === 'pending' && data['pendingAdmission']) {
+        return {
+            status: 'pending',
+            pendingAdmission: data['pendingAdmission'],
+        };
+    }
+    if (data['status'] === 'approved') {
+        return { status: 'approved', chat: data['chat'] };
+    }
+    return { chat: data['chat'] };
+}
 /**
  * POST /chats/:chatId/messages as an impersonated delegate agent.
- * Requires operator token + X-Agent-Id (ZIG-222).
  */
 export async function sendChatMessage(input, creds) {
     assertCreds(creds, 'send chat message');
@@ -84,7 +113,6 @@ export async function sendChatMessage(input, creds) {
 export async function listMyChats(creds) {
     assertCreds(creds, 'list my chats');
     try {
-        // Canonical REST: GET /chats/mine.
         const res = await fetch(`${getBackendUrl()}/chats/mine`, {
             method: 'GET',
             headers: buildHeaders(creds),

package/dist/http/ContextGrantsClient.d.ts

@@ -0,0 +1,49 @@
+import 'dotenv/config';
+export type ContextGrantScopeKind = 'chat' | 'agreement' | 'org';
+export type ContextTemporal = 'from-now' | 'from-start';
+export interface ContextGrantScope {
+    kind: ContextGrantScopeKind;
+    id: string;
+}
+export interface ContextGrantRecord {
+    grantId: string;
+    issuerId: string;
+    holderId: string;
+    scopeKind: ContextGrantScopeKind;
+    scopeId: string;
+    temporal: ContextTemporal;
+    watermarkAt: string;
+    parentGrantId: string | null;
+    expiresAt: string | null;
+    revoked: boolean;
+    createdAt: string;
+}
+export interface IssueContextGrantInput {
+    holderId: string;
+    scope: ContextGrantScope;
+    temporal?: ContextTemporal;
+    expiresAt?: string | null;
+}
+export interface DelegateContextGrantInput {
+    holderId: string;
+    scope: ContextGrantScope;
+    temporal: ContextTemporal;
+    expiresAt?: string | null;
+    watermarkAt?: string;
+}
+/**
+ * ZIG-411 context grant management — list / issue / delegate / revoke.
+ */
+export declare class ContextGrantsClient {
+    private readonly operatorKey;
+    private readonly agentId;
+    private readonly baseUrl;
+    constructor(operatorKey: string, agentId: string, baseUrl?: string);
+    listGrants(holderId?: string): Promise<ContextGrantRecord[]>;
+    issueGrant(input: IssueContextGrantInput): Promise<ContextGrantRecord>;
+    delegateGrant(parentGrantId: string, input: DelegateContextGrantInput): Promise<ContextGrantRecord>;
+    revokeGrant(grantId: string): Promise<{
+        status: string;
+        revokedCount?: number;
+    }>;
+}

package/dist/http/ContextGrantsClient.js

@@ -0,0 +1,130 @@
+import 'dotenv/config';
+import { getBackendUrl } from '../utils/urlUtils.js';
+import { ApiError } from '../types.js';
+function buildHeaders(creds) {
+    return {
+        'content-type': 'application/json',
+        Authorization: `Bearer ${creds.operatorKey}`,
+        'X-Agent-Id': creds.agentId,
+    };
+}
+function assertCreds(creds, op) {
+    if (!creds?.operatorKey)
+        throw new Error(`operatorKey is required for ${op}`);
+    if (!creds?.agentId)
+        throw new Error(`agentId is required for ${op}`);
+}
+function throwApiError(response, responseBody, defaultMessage) {
+    let message = defaultMessage;
+    if (responseBody) {
+        try {
+            const d = JSON.parse(responseBody);
+            message =
+                d['details'] ||
+                    d['error'] ||
+                    d['message'] ||
+                    defaultMessage;
+        }
+        catch {
+            message = responseBody || defaultMessage;
+        }
+    }
+    throw new ApiError(message, response.status, responseBody);
+}
+/**
+ * ZIG-411 context grant management — list / issue / delegate / revoke.
+ */
+export class ContextGrantsClient {
+    operatorKey;
+    agentId;
+    baseUrl;
+    constructor(operatorKey, agentId, baseUrl) {
+        if (!operatorKey) {
+            throw new Error('ContextGrantsClient: operatorKey is required');
+        }
+        if (!agentId) {
+            throw new Error('ContextGrantsClient: agentId is required (operator-token impersonation)');
+        }
+        this.operatorKey = operatorKey;
+        this.agentId = agentId;
+        this.baseUrl = baseUrl || getBackendUrl();
+    }
+    async listGrants(holderId) {
+        assertCreds({ operatorKey: this.operatorKey, agentId: this.agentId }, 'listGrants');
+        const qs = holderId
+            ? `?${new URLSearchParams({ holderId }).toString()}`
+            : '';
+        const res = await fetch(`${this.baseUrl}/context/grants${qs}`, {
+            headers: buildHeaders({
+                operatorKey: this.operatorKey,
+                agentId: this.agentId,
+            }),
+        });
+        const body = await res.text().catch(() => '');
+        if (!res.ok) {
+            throwApiError(res, body, `listGrants failed: ${res.status} ${res.statusText}`);
+        }
+        const parsed = JSON.parse(body);
+        return parsed.grants ?? [];
+    }
+    async issueGrant(input) {
+        assertCreds({ operatorKey: this.operatorKey, agentId: this.agentId }, 'issueGrant');
+        const res = await fetch(`${this.baseUrl}/context/grants`, {
+            method: 'POST',
+            headers: buildHeaders({
+                operatorKey: this.operatorKey,
+                agentId: this.agentId,
+            }),
+            body: JSON.stringify({
+                holderId: input.holderId,
+                scope: input.scope,
+                temporal: input.temporal,
+                expiresAt: input.expiresAt,
+            }),
+        });
+        const body = await res.text().catch(() => '');
+        if (!res.ok) {
+            throwApiError(res, body, `issueGrant failed: ${res.status} ${res.statusText}`);
+        }
+        const parsed = JSON.parse(body);
+        if (!parsed.grant?.grantId) {
+            throw new Error('Invalid response: expected { grant } from POST /context/grants');
+        }
+        return parsed.grant;
+    }
+    async delegateGrant(parentGrantId, input) {
+        assertCreds({ operatorKey: this.operatorKey, agentId: this.agentId }, 'delegateGrant');
+        const res = await fetch(`${this.baseUrl}/context/grants/${encodeURIComponent(parentGrantId)}/delegate`, {
+            method: 'POST',
+            headers: buildHeaders({
+                operatorKey: this.operatorKey,
+                agentId: this.agentId,
+            }),
+            body: JSON.stringify(input),
+        });
+        const body = await res.text().catch(() => '');
+        if (!res.ok) {
+            throwApiError(res, body, `delegateGrant failed: ${res.status} ${res.statusText}`);
+        }
+        const parsed = JSON.parse(body);
+        if (!parsed.grant?.grantId) {
+            throw new Error('Invalid response: expected { grant } from POST /context/grants/:id/delegate');
+        }
+        return parsed.grant;
+    }
+    async revokeGrant(grantId) {
+        assertCreds({ operatorKey: this.operatorKey, agentId: this.agentId }, 'revokeGrant');
+        const res = await fetch(`${this.baseUrl}/context/grants/${encodeURIComponent(grantId)}`, {
+            method: 'DELETE',
+            headers: buildHeaders({
+                operatorKey: this.operatorKey,
+                agentId: this.agentId,
+            }),
+        });
+        const body = await res.text().catch(() => '');
+        if (!res.ok) {
+            throwApiError(res, body, `revokeGrant failed: ${res.status} ${res.statusText}`);
+        }
+        return JSON.parse(body);
+    }
+}

package/dist/http/index.d.ts

@@ -12,5 +12,7 @@ export { ContextReadClient } from './ContextReadClient.js';
 export type { ContextReadType, ContextReadQuery, ContextReadEnvelope, } from './ContextReadClient.js';
 export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
 export type { ContextReachDescriptor } from './ContextDiscoveryClient.js';
+export { ContextGrantsClient } from './ContextGrantsClient.js';
+export type { ContextGrantRecord, ContextGrantScope, ContextGrantScopeKind, ContextTemporal, IssueContextGrantInput, DelegateContextGrantInput, } from './ContextGrantsClient.js';
 export { AgentSearchClient } from './AgentSearchClient.js';
 export { TelemetryClient } from './TelemetryClient.js';

package/dist/http/index.js

@@ -7,5 +7,6 @@ export { ArtifactsClient } from './ArtifactsClient.js';
 export { ScopeClient } from './ScopeClient.js';
 export { ContextReadClient } from './ContextReadClient.js';
 export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
+export { ContextGrantsClient } from './ContextGrantsClient.js';
 export { AgentSearchClient } from './AgentSearchClient.js';
 export { TelemetryClient } from './TelemetryClient.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/api-client",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "HTTP and WebSocket client for the Ziggs backend API",
   "type": "module",
   "main": "dist/index.js",