@rkat/sdk 0.5.1 → 0.5.2

package/dist/client.js

@@ -252,21 +252,39 @@ export class MeerkatClient {
         return new DeferredSession(this, String(raw.session_id ?? ""), raw.session_ref != null ? String(raw.session_ref) : undefined);
     }
     // -- Session queries ----------------------------------------------------
-    async listSessions() {
-        const result = await this.request("session/list", {});
+    async listSessions(options) {
+        const params = {};
+        if (options?.labels)
+            params.labels = options.labels;
+        if (options?.limit !== undefined)
+            params.limit = options.limit;
+        if (options?.offset !== undefined)
+            params.offset = options.offset;
+        const result = await this.request("session/list", params);
         const sessions = result.sessions ?? [];
-        return sessions.map((s) => ({
-            sessionId: String(s.session_id ?? ""),
-            sessionRef: s.session_ref != null ? String(s.session_ref) : undefined,
-            createdAt: String(s.created_at ?? ""),
-            updatedAt: String(s.updated_at ?? ""),
-            messageCount: Number(s.message_count ?? 0),
-            totalTokens: Number(s.total_tokens ?? 0),
-            isActive: Boolean(s.is_active),
-        }));
+        return sessions.map((s) => MeerkatClient.parseSessionInfo(s));
     }
     async readSession(sessionId) {
-        return this.request("session/read", { session_id: sessionId });
+        const raw = await this.request("session/read", { session_id: sessionId });
+        return MeerkatClient.parseSessionInfo(raw);
+    }
+    async sendExternalEvent(sessionId, payload, options) {
+        const params = { session_id: sessionId, payload };
+        if (options?.source !== undefined) {
+            params.source = options.source;
+        }
+        return this.request("session/external_event", params);
+    }
+    async injectContext(sessionId, text, options) {
+        const params = { session_id: sessionId, text };
+        if (options?.source !== undefined) {
+            params.source = options.source;
+        }
+        if (options?.idempotencyKey !== undefined) {
+            params.idempotency_key = options.idempotencyKey;
+        }
+        const result = await this.request("session/inject_context", params);
+        return { status: String(result.status ?? "") };
     }
     async readSessionHistory(sessionId, options) {
         const params = {
@@ -297,21 +315,24 @@ export class MeerkatClient {
     }
     // -- Config -------------------------------------------------------------
     async getConfig() {
-        return this.request("config/get", {});
+        const raw = await this.request("config/get", {});
+        return MeerkatClient.parseConfigEnvelope(raw);
     }
     async setConfig(config, options) {
         const params = { config };
         if (options?.expectedGeneration !== undefined) {
             params.expected_generation = options.expectedGeneration;
         }
-        return this.request("config/set", params);
+        const raw = await this.request("config/set", params);
+        return MeerkatClient.parseConfigEnvelope(raw);
     }
     async patchConfig(patch, options) {
         const params = { patch };
         if (options?.expectedGeneration !== undefined) {
             params.expected_generation = options.expectedGeneration;
         }
-        return this.request("config/patch", params);
+        const raw = await this.request("config/patch", params);
+        return MeerkatClient.parseConfigEnvelope(raw);
     }
     async mcpAdd(params) {
         const raw = await this.request("mcp/add", params);
@@ -355,6 +376,76 @@ export class MeerkatClient {
             dataBase64: String(result.data ?? ""),
         };
     }
+    async getModelsCatalog() {
+        const result = await this.request("models/catalog", {});
+        return MeerkatClient.parseModelsCatalog(result);
+    }
+    async createSchedule(request) {
+        const result = await this.request("schedule/create", MeerkatClient.toWireCreateScheduleRequest(request));
+        return MeerkatClient.parseSchedule(result);
+    }
+    async getSchedule(scheduleId) {
+        const result = await this.request("schedule/get", { schedule_id: scheduleId });
+        return MeerkatClient.parseSchedule(result);
+    }
+    async listSchedules(_options) {
+        const params = {};
+        if (_options?.labels)
+            params.labels = _options.labels;
+        if (_options?.limit !== undefined)
+            params.limit = _options.limit;
+        if (_options?.offset !== undefined)
+            params.offset = _options.offset;
+        const result = await this.request("schedule/list", params);
+        const schedules = Array.isArray(result.schedules)
+            ? result.schedules
+            : [];
+        return schedules.map((schedule) => MeerkatClient.parseSchedule(schedule));
+    }
+    async updateSchedule(request) {
+        const params = {
+            schedule_id: request.scheduleId,
+            ...MeerkatClient.toWireUpdateSchedulePatch(request.update),
+        };
+        const result = await this.request("schedule/update", params);
+        return MeerkatClient.parseSchedule(result);
+    }
+    async pauseSchedule(scheduleId) {
+        const result = await this.request("schedule/pause", { schedule_id: scheduleId });
+        return MeerkatClient.parseSchedule(result);
+    }
+    async resumeSchedule(scheduleId) {
+        const result = await this.request("schedule/resume", { schedule_id: scheduleId });
+        return MeerkatClient.parseSchedule(result);
+    }
+    async deleteSchedule(scheduleId) {
+        const result = await this.request("schedule/delete", { schedule_id: scheduleId });
+        return MeerkatClient.parseSchedule(result);
+    }
+    async listScheduleOccurrences(scheduleId, options) {
+        const params = { schedule_id: scheduleId };
+        if (options?.includeTerminal !== undefined) {
+            params.include_terminal = options.includeTerminal;
+        }
+        const result = await this.request("schedule/occurrences", params);
+        const occurrences = Array.isArray(result.occurrences)
+            ? result.occurrences.map((occurrence) => MeerkatClient.parseScheduleOccurrence(occurrence))
+            : [];
+        return { occurrences };
+    }
+    async listScheduleTools() {
+        const result = await this.request("schedule/tools", {});
+        const tools = Array.isArray(result.tools)
+            ? result.tools
+            : [];
+        return { tools };
+    }
+    async callScheduleTool(request) {
+        return this.request("schedule/call", {
+            name: request.name,
+            arguments: request.arguments ?? {},
+        });
+    }
     async subscribeSessionEvents(sessionId) {
         return this.openEventSubscription("session/stream_open", { session_id: sessionId }, "session/stream_close", MeerkatClient.parseAgentEventEnvelope);
     }
@@ -451,6 +542,33 @@ export class MeerkatClient {
             additional_instructions: options.additionalInstructions,
         });
     }
+    async spawnMobMembers(mobId, specs) {
+        const result = await this.request("mob/spawn_many", {
+            mob_id: mobId,
+            specs: specs.map((spec) => ({
+                profile: spec.profile,
+                meerkat_id: spec.meerkatId,
+                initial_message: spec.initialMessage,
+                runtime_mode: spec.runtimeMode,
+                backend: spec.backend,
+                resume_session_id: spec.resumeSessionId,
+                labels: spec.labels,
+                context: spec.context,
+                additional_instructions: spec.additionalInstructions,
+            })),
+        });
+        const entries = Array.isArray(result.results)
+            ? result.results
+            : [];
+        return entries.map((entry) => ({
+            ok: Boolean(entry.ok),
+            memberRef: entry.member_ref && typeof entry.member_ref === "object"
+                ? entry.member_ref
+                : undefined,
+            sessionId: entry.session_id != null ? String(entry.session_id) : undefined,
+            error: entry.error != null ? String(entry.error) : undefined,
+        }));
+    }
     async retireMobMember(mobId, meerkatId) {
         await this.request("mob/retire", { mob_id: mobId, meerkat_id: meerkatId });
     }
@@ -555,11 +673,12 @@ export class MeerkatClient {
         return this.waitMobKickoff(mobId, options);
     }
     async spawnMobHelper(mobId, prompt, options) {
+        const roleName = options?.roleName ?? options?.profileName;
         const result = await this.request("mob/spawn_helper", {
             mob_id: mobId,
             prompt,
             meerkat_id: options?.meerkatId,
-            profile_name: options?.profileName,
+            role_name: roleName,
             runtime_mode: options?.runtimeMode,
             backend: options?.backend,
         });
@@ -570,12 +689,13 @@ export class MeerkatClient {
         };
     }
     async forkMobHelper(mobId, sourceMemberId, prompt, options) {
+        const roleName = options?.roleName ?? options?.profileName;
         const result = await this.request("mob/fork_helper", {
             mob_id: mobId,
             source_member_id: sourceMemberId,
             prompt,
             meerkat_id: options?.meerkatId,
-            profile_name: options?.profileName,
+            role_name: roleName,
             fork_context: options?.forkContext,
             runtime_mode: options?.runtimeMode,
             backend: options?.backend,
@@ -610,6 +730,56 @@ export class MeerkatClient {
             idempotency_key: options?.idempotencyKey,
         });
     }
+    async readMobEvents(mobId, options) {
+        const params = { mob_id: mobId };
+        if (options?.afterCursor !== undefined) {
+            params.after_cursor = options.afterCursor;
+        }
+        if (options?.limit !== undefined) {
+            params.limit = options.limit;
+        }
+        const result = await this.request("mob/events", params);
+        const events = Array.isArray(result.events)
+            ? result.events
+            : [];
+        return { events };
+    }
+    async createMobProfile(name, profile) {
+        const raw = await this.request("mob/profile/create", {
+            name,
+            profile,
+        });
+        return MeerkatClient.parseMobProfileLookup(raw);
+    }
+    async getMobProfile(name) {
+        const raw = await this.request("mob/profile/get", { name });
+        return MeerkatClient.parseMobProfileLookup(raw);
+    }
+    async listMobProfiles() {
+        const raw = await this.request("mob/profile/list", {});
+        const profiles = Array.isArray(raw.profiles)
+            ? raw.profiles
+            : [];
+        return profiles.map((profile) => MeerkatClient.parseMobProfileLookup(profile));
+    }
+    async updateMobProfile(name, profile, expectedRevision) {
+        const raw = await this.request("mob/profile/update", {
+            name,
+            profile,
+            expected_revision: expectedRevision,
+        });
+        return MeerkatClient.parseMobProfileLookup(raw);
+    }
+    async deleteMobProfile(name, expectedRevision) {
+        const raw = await this.request("mob/profile/delete", {
+            name,
+            expected_revision: expectedRevision,
+        });
+        return {
+            name: String(raw.name ?? name),
+            deletedRevision: Number(raw.deleted_revision ?? expectedRevision),
+        };
+    }
     async listMobFlows(mobId) {
         const result = await this.request("mob/flows", { mob_id: mobId });
         return result.flows ?? [];
@@ -700,6 +870,9 @@ export class MeerkatClient {
                 blocked_tools: options.flowToolOverlay.blockedTools,
             };
         }
+        if (options?.additionalInstructions != null) {
+            params.additional_instructions = options.additionalInstructions;
+        }
         if (options?.keepAlive != null)
             params.keep_alive = options.keepAlive;
         if (options?.model)
@@ -744,6 +917,26 @@ export class MeerkatClient {
                 blocked_tools: options.flowToolOverlay.blockedTools,
             };
         }
+        if (options?.additionalInstructions != null) {
+            params.additional_instructions = options.additionalInstructions;
+        }
+        if (options?.keepAlive != null)
+            params.keep_alive = options.keepAlive;
+        if (options?.model)
+            params.model = options.model;
+        if (options?.provider)
+            params.provider = options.provider;
+        if (options?.maxTokens)
+            params.max_tokens = options.maxTokens;
+        if (options?.systemPrompt)
+            params.system_prompt = options.systemPrompt;
+        if (options?.outputSchema)
+            params.output_schema = options.outputSchema;
+        if (options?.structuredOutputRetries != null) {
+            params.structured_output_retries = options.structuredOutputRetries;
+        }
+        if (options?.providerParams)
+            params.provider_params = options.providerParams;
         const rpcRequest = { jsonrpc: "2.0", id: requestId, method: "turn/start", params };
         this.process.stdin.write(JSON.stringify(rpcRequest) + "\n");
         return new EventStream({
@@ -771,7 +964,8 @@ export class MeerkatClient {
         return this.peers(sessionId);
     }
     async send(sessionId, command) {
-        return this.request("comms/send", { session_id: sessionId, ...command });
+        const result = await this.request("comms/send", { session_id: sessionId, ...command });
+        return MeerkatClient.parseCommsSendReceipt(result);
     }
     async peers(sessionId) {
         return this.request("comms/peers", { session_id: sessionId });
@@ -1035,6 +1229,234 @@ export class MeerkatClient {
             skillDiagnostics: MeerkatClient.parseSkillDiagnostics(data.skill_diagnostics),
         };
     }
+    static parseSessionInfo(data) {
+        const labelsRaw = data.labels && typeof data.labels === "object"
+            ? data.labels
+            : {};
+        const labels = Object.fromEntries(Object.entries(labelsRaw).map(([key, value]) => [key, String(value)]));
+        return {
+            sessionId: String(data.session_id ?? ""),
+            sessionRef: data.session_ref != null ? String(data.session_ref) : undefined,
+            createdAt: Number(data.created_at ?? 0),
+            updatedAt: Number(data.updated_at ?? 0),
+            messageCount: Number(data.message_count ?? 0),
+            isActive: Boolean(data.is_active),
+            totalTokens: data.total_tokens != null ? Number(data.total_tokens) : undefined,
+            model: data.model != null ? String(data.model) : undefined,
+            provider: data.provider != null ? String(data.provider) : undefined,
+            lastAssistantText: data.last_assistant_text != null ? String(data.last_assistant_text) : undefined,
+            labels,
+        };
+    }
+    static parseConfigEnvelope(data) {
+        const rawConfig = data.config && typeof data.config === "object"
+            ? data.config
+            : {};
+        const rawResolvedPaths = data.resolved_paths && typeof data.resolved_paths === "object"
+            ? data.resolved_paths
+            : undefined;
+        const resolvedPaths = rawResolvedPaths
+            ? Object.fromEntries(Object.entries(rawResolvedPaths).map(([key, value]) => [key, String(value)]))
+            : undefined;
+        return {
+            config: rawConfig,
+            generation: Number(data.generation ?? 0),
+            realmId: data.realm_id != null ? String(data.realm_id) : undefined,
+            instanceId: data.instance_id != null ? String(data.instance_id) : undefined,
+            backend: data.backend != null ? String(data.backend) : undefined,
+            resolvedPaths,
+        };
+    }
+    static parseCommsSendReceipt(data) {
+        return {
+            ...data,
+            requestId: data.request_id != null ? String(data.request_id) : undefined,
+            interactionId: data.interaction_id != null ? String(data.interaction_id) : undefined,
+            inputId: data.input_id != null ? String(data.input_id) : undefined,
+        };
+    }
+    static parseModelsCatalog(data) {
+        const providersRaw = Array.isArray(data.providers)
+            ? data.providers
+            : [];
+        let contractVersion = { major: 0, minor: 0, patch: 0 };
+        if (data.contract_version && typeof data.contract_version === "object") {
+            const contractVersionRaw = data.contract_version;
+            contractVersion = {
+                major: Number(contractVersionRaw.major ?? 0),
+                minor: Number(contractVersionRaw.minor ?? 0),
+                patch: Number(contractVersionRaw.patch ?? 0),
+            };
+        }
+        else if (typeof data.contract_version === "string") {
+            const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(data.contract_version);
+            if (match) {
+                contractVersion = {
+                    major: Number(match[1]),
+                    minor: Number(match[2]),
+                    patch: Number(match[3]),
+                };
+            }
+        }
+        return {
+            contractVersion,
+            providers: providersRaw.map((provider) => ({
+                provider: String(provider.provider ?? ""),
+                defaultModelId: String(provider.default_model_id ?? ""),
+                models: Array.isArray(provider.models)
+                    ? provider.models.map((model) => ({
+                        id: String(model.id ?? ""),
+                        displayName: String(model.display_name ?? ""),
+                        tier: String(model.tier ?? "supported") === "recommended"
+                            ? "recommended"
+                            : "supported",
+                        contextWindow: model.context_window != null ? Number(model.context_window) : undefined,
+                        maxOutputTokens: model.max_output_tokens != null ? Number(model.max_output_tokens) : undefined,
+                        serverId: model.server_id != null ? String(model.server_id) : undefined,
+                        profile: model.profile && typeof model.profile === "object"
+                            ? {
+                                modelFamily: String(model.profile.model_family ?? ""),
+                                supportsTemperature: Boolean(model.profile.supports_temperature),
+                                supportsThinking: Boolean(model.profile.supports_thinking),
+                                supportsReasoning: Boolean(model.profile.supports_reasoning),
+                                inlineVideo: Boolean(model.profile.inline_video),
+                                paramsSchema: model.profile.params_schema,
+                            }
+                            : undefined,
+                    }))
+                    : [],
+            })),
+        };
+    }
+    static parseSchedule(data) {
+        const labelsRaw = data.labels && typeof data.labels === "object"
+            ? data.labels
+            : {};
+        return {
+            scheduleId: String(data.schedule_id ?? ""),
+            phase: String(data.phase ?? ""),
+            revision: typeof data.revision === "object" && data.revision !== null
+                ? Number(data.revision["0"] ?? 0)
+                : Number(data.revision ?? 0),
+            name: data.name != null ? String(data.name) : undefined,
+            description: data.description != null ? String(data.description) : undefined,
+            trigger: data.trigger && typeof data.trigger === "object"
+                ? data.trigger
+                : {},
+            target: data.target && typeof data.target === "object"
+                ? data.target
+                : {},
+            misfirePolicy: data.misfire_policy != null
+                ? data.misfire_policy
+                : undefined,
+            overlapPolicy: data.overlap_policy != null ? String(data.overlap_policy) : undefined,
+            missingTargetPolicy: data.missing_target_policy != null ? String(data.missing_target_policy) : undefined,
+            planningHorizonDays: data.planning_horizon_days != null ? Number(data.planning_horizon_days) : undefined,
+            planningHorizonOccurrences: data.planning_horizon_occurrences != null
+                ? Number(data.planning_horizon_occurrences)
+                : undefined,
+            nextOccurrenceOrdinal: typeof data.next_occurrence_ordinal === "object"
+                ? Number(data.next_occurrence_ordinal["0"] ?? 0)
+                : data.next_occurrence_ordinal != null
+                    ? Number(data.next_occurrence_ordinal)
+                    : undefined,
+            planningCursorUtc: data.planning_cursor_utc != null ? String(data.planning_cursor_utc) : undefined,
+            createdAtUtc: data.created_at_utc != null ? String(data.created_at_utc) : undefined,
+            updatedAtUtc: data.updated_at_utc != null ? String(data.updated_at_utc) : undefined,
+            deletedAtUtc: data.deleted_at_utc != null ? String(data.deleted_at_utc) : undefined,
+            labels: Object.fromEntries(Object.entries(labelsRaw).map(([key, value]) => [key, String(value)])),
+        };
+    }
+    static parseScheduleOccurrence(data) {
+        return {
+            occurrenceId: String(data.occurrence_id ?? ""),
+            scheduleId: String(data.schedule_id ?? ""),
+            scheduleRevision: typeof data.schedule_revision === "object" && data.schedule_revision !== null
+                ? Number(data.schedule_revision["0"] ?? 0)
+                : Number(data.schedule_revision ?? 0),
+            occurrenceOrdinal: typeof data.occurrence_ordinal === "object" && data.occurrence_ordinal !== null
+                ? Number(data.occurrence_ordinal["0"] ?? 0)
+                : Number(data.occurrence_ordinal ?? 0),
+            phase: String(data.phase ?? ""),
+            dueAtUtc: String(data.due_at_utc ?? ""),
+            triggerSnapshot: data.trigger_snapshot && typeof data.trigger_snapshot === "object"
+                ? data.trigger_snapshot
+                : {},
+            targetSnapshot: data.target_snapshot && typeof data.target_snapshot === "object"
+                ? data.target_snapshot
+                : {},
+            misfirePolicy: data.misfire_policy != null
+                ? data.misfire_policy
+                : undefined,
+            overlapPolicy: data.overlap_policy != null ? String(data.overlap_policy) : undefined,
+            missingTargetPolicy: data.missing_target_policy != null ? String(data.missing_target_policy) : undefined,
+            claimedBy: data.claimed_by != null ? String(data.claimed_by) : undefined,
+            leaseExpiresAtUtc: data.lease_expires_at_utc != null ? String(data.lease_expires_at_utc) : undefined,
+            deliveryCorrelationId: data.delivery_correlation_id != null ? String(data.delivery_correlation_id) : undefined,
+            lastReceipt: data.last_receipt && typeof data.last_receipt === "object"
+                ? data.last_receipt
+                : undefined,
+            failureClass: data.failure_class != null ? String(data.failure_class) : undefined,
+            failureDetail: data.failure_detail != null ? String(data.failure_detail) : undefined,
+            attemptCount: data.attempt_count != null ? Number(data.attempt_count) : undefined,
+            createdAtUtc: data.created_at_utc != null ? String(data.created_at_utc) : undefined,
+            claimedAtUtc: data.claimed_at_utc != null ? String(data.claimed_at_utc) : undefined,
+            dispatchedAtUtc: data.dispatched_at_utc != null ? String(data.dispatched_at_utc) : undefined,
+            completedAtUtc: data.completed_at_utc != null ? String(data.completed_at_utc) : undefined,
+            supersededByRevision: typeof data.superseded_by_revision === "object" && data.superseded_by_revision !== null
+                ? Number(data.superseded_by_revision["0"] ?? 0)
+                : data.superseded_by_revision != null
+                    ? Number(data.superseded_by_revision)
+                    : undefined,
+        };
+    }
+    static parseMobProfileLookup(data) {
+        if (Boolean(data.not_found)) {
+            return {
+                notFound: true,
+                name: String(data.name ?? ""),
+            };
+        }
+        return {
+            notFound: false,
+            name: String(data.name ?? ""),
+            profile: data.profile && typeof data.profile === "object"
+                ? data.profile
+                : undefined,
+            revision: data.revision != null ? Number(data.revision) : undefined,
+            createdAt: data.created_at != null ? String(data.created_at) : undefined,
+            updatedAt: data.updated_at != null ? String(data.updated_at) : undefined,
+        };
+    }
+    static toWireCreateScheduleRequest(request) {
+        return {
+            name: request.name,
+            description: request.description,
+            trigger: request.trigger,
+            target: request.target,
+            misfire_policy: request.misfirePolicy,
+            overlap_policy: request.overlapPolicy,
+            missing_target_policy: request.missingTargetPolicy,
+            labels: request.labels,
+            planning_horizon_days: request.planningHorizonDays,
+            planning_horizon_occurrences: request.planningHorizonOccurrences,
+        };
+    }
+    static toWireUpdateSchedulePatch(update) {
+        return {
+            expected_revision: update.expectedRevision,
+            name: update.name,
+            description: update.description,
+            trigger: update.trigger,
+            target: update.target,
+            misfire_policy: update.misfirePolicy,
+            overlap_policy: update.overlapPolicy,
+            missing_target_policy: update.missingTargetPolicy,
+            planning_horizon_days: update.planningHorizonDays,
+            planning_horizon_occurrences: update.planningHorizonOccurrences,
+            labels: update.labels,
+        };
+    }
     static parseSessionHistory(data) {
         const rawMessages = Array.isArray(data.messages)
             ? data.messages
@@ -1050,6 +1472,10 @@ export class MeerkatClient {
         };
     }
     static parseSessionMessage(data) {
+        const role = String(data.role ?? "");
+        const contentValue = role === "system_notice" && data.content == null && data.body != null
+            ? String(data.body)
+            : data.content;
         const rawToolCalls = Array.isArray(data.tool_calls)
             ? data.tool_calls
             : [];
@@ -1060,8 +1486,8 @@ export class MeerkatClient {
             ? data.results
             : [];
         return {
-            role: String(data.role ?? ""),
-            content: data.content != null ? MeerkatClient.parseContentInput(data.content) : undefined,
+            role,
+            content: contentValue != null ? MeerkatClient.parseContentInput(contentValue) : undefined,
             toolCalls: rawToolCalls.map((toolCall) => ({
                 id: String(toolCall.id ?? ""),
                 name: String(toolCall.name ?? ""),
@@ -1233,6 +1659,17 @@ export class MeerkatClient {
             params.skill_refs = wireRefs;
         if (options.skillReferences != null)
             params.skill_references = options.skillReferences;
+        if (options.labels != null)
+            params.labels = options.labels;
+        if (options.additionalInstructions != null) {
+            params.additional_instructions = options.additionalInstructions;
+        }
+        if (options.appContext !== undefined)
+            params.app_context = options.appContext;
+        if (options.shellEnv != null)
+            params.shell_env = options.shellEnv;
+        if (options.externalTools != null)
+            params.external_tools = options.externalTools;
         return params;
     }
     // -- Binary resolution --------------------------------------------------