graphlit-client 1.0.20260418002 → 1.0.20260419002

package/dist/client.d.ts

@@ -1601,6 +1601,91 @@ declare class Graphlit {
      * @returns The matching persons.
      */
     lookupPersons(linkedInUrl?: string, email?: string): Promise<Types.LookupPersonsQuery>;
+    /**
+     * Creates a replica.
+     * @param replica - The replica to create.
+     * @returns The created replica.
+     */
+    createReplica(replica: Types.ReplicaInput): Promise<Types.CreateReplicaMutation>;
+    /**
+     * Updates a replica.
+     * @param replica - The replica to update.
+     * @returns The updated replica.
+     */
+    updateReplica(replica: Types.ReplicaUpdateInput): Promise<Types.UpdateReplicaMutation>;
+    /**
+     * Creates or updates a replica.
+     * @param replica - The replica to create or update.
+     * @returns The created or updated replica.
+     */
+    upsertReplica(replica: Types.ReplicaInput): Promise<Types.UpsertReplicaMutation>;
+    /**
+     * Deletes a replica.
+     * @param id - The ID of the replica to delete.
+     * @returns The deleted replica.
+     */
+    deleteReplica(id: string): Promise<Types.DeleteReplicaMutation>;
+    /**
+     * Deletes multiple replicas.
+     * @param ids - The IDs of the replicas to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted replicas.
+     */
+    deleteReplicas(ids: string[], isSynchronous?: boolean): Promise<Types.DeleteReplicasMutation>;
+    /**
+     * Deletes all replicas based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting replicas.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
+    deleteAllReplicas(filter?: Types.ReplicaFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllReplicasMutation>;
+    /**
+     * Triggers a replica to run immediately.
+     * @param id - The ID of the replica to trigger.
+     * @returns The triggered replica.
+     */
+    triggerReplica(id: string): Promise<Types.TriggerReplicaMutation>;
+    /**
+     * Enables a replica.
+     * @param id - The ID of the replica to enable.
+     * @returns The enabled replica.
+     */
+    enableReplica(id: string): Promise<Types.EnableReplicaMutation>;
+    /**
+     * Disables a replica.
+     * @param id - The ID of the replica to disable.
+     * @returns The disabled replica.
+     */
+    disableReplica(id: string): Promise<Types.DisableReplicaMutation>;
+    /**
+     * Lookup a replica given its ID.
+     * @param id - ID of the replica.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The replica.
+     */
+    getReplica(id: string, correlationId?: string): Promise<Types.GetReplicaQuery>;
+    /**
+     * Retrieves replicas based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving replicas.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The replicas.
+     */
+    queryReplicas(filter?: Types.ReplicaFilter, correlationId?: string): Promise<Types.QueryReplicasQuery>;
+    /**
+     * Counts replicas based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting replicas.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of replicas.
+     */
+    countReplicas(filter?: Types.ReplicaFilter, correlationId?: string): Promise<Types.CountReplicasQuery>;
+    /**
+     * Checks if a replica exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns Whether the replica exists.
+     */
+    replicaExists(filter?: Types.ReplicaFilter, correlationId?: string): Promise<Types.ReplicaExistsQuery>;
     /**
      * Creates a skill.
      * @param skill - The skill to create.
@@ -3017,23 +3102,21 @@ declare class Graphlit {
      * Recognizes two invocation shapes:
      *   1. Direct — a tool call whose `name` is `"task_complete"`.
      *   2. Wrapped — a tool call whose arguments JSON has shape
-     *      `{ tool: "task_complete", parameters: { summary?, ... } }`. This is
-     *      the common pattern used by dynamic-toolset clients that expose a
-     *      single meta-executor (often named `execute_tool`) at the top level
-     *      and route every underlying tool through it.
+     *      `{ tool: "task_complete", parameters: { ... } }`. This is the common
+     *      pattern used by dynamic-toolset clients that expose a single
+     *      meta-executor (often named `execute_tool`) at the top level and
+     *      route every underlying tool through it.
      *
      * Detection is invocation-agnostic: whether the model called task_complete
-     * directly or via a meta-executor, the harness treats the turn as complete
-     * and surfaces the provided summary. Callers that only register a direct
-     * top-level task_complete still work — the wrapped path is simply inert
-     * when no meta-executor is in use.
+     * directly or via a meta-executor, the harness treats the turn as complete.
+     * Callers that only register a direct top-level task_complete still work —
+     * the wrapped path is simply inert when no meta-executor is in use.
      */
     private detectTaskComplete;
     /**
-     * Scan a list of messages for a task_complete invocation. Returns the first
-     * match found across all tool calls in all messages. Convenience wrapper
-     * over `detectTaskComplete` for the streamAgent loop, which works with
-     * `intermediateMessages` rather than a single tool-call list.
+     * Scan a list of messages for a task_complete invocation. Convenience
+     * wrapper over `detectTaskComplete` for the streamAgent loop, which works
+     * with `intermediateMessages` rather than a single tool-call list.
      */
     private detectTaskCompleteInMessages;
     /**

package/dist/client.js

@@ -2878,11 +2878,136 @@ class Graphlit {
         });
     }
     // ──────────────────────────────────────────────────────────────────────────
+    // Replicas
+    // ──────────────────────────────────────────────────────────────────────────
+    /**
+     * Creates a replica.
+     * @param replica - The replica to create.
+     * @returns The created replica.
+     */
+    async createReplica(replica) {
+        return this.mutateAndCheckError(Documents.CreateReplica, {
+            replica: replica,
+        });
+    }
+    /**
+     * Updates a replica.
+     * @param replica - The replica to update.
+     * @returns The updated replica.
+     */
+    async updateReplica(replica) {
+        return this.mutateAndCheckError(Documents.UpdateReplica, { replica: replica });
+    }
+    /**
+     * Creates or updates a replica.
+     * @param replica - The replica to create or update.
+     * @returns The created or updated replica.
+     */
+    async upsertReplica(replica) {
+        return this.mutateAndCheckError(Documents.UpsertReplica, { replica: replica });
+    }
+    /**
+     * Deletes a replica.
+     * @param id - The ID of the replica to delete.
+     * @returns The deleted replica.
+     */
+    async deleteReplica(id) {
+        return this.mutateAndCheckError(Documents.DeleteReplica, { id: id });
+    }
+    /**
+     * Deletes multiple replicas.
+     * @param ids - The IDs of the replicas to delete.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @returns The deleted replicas.
+     */
+    async deleteReplicas(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteReplicas, { ids: ids, isSynchronous: isSynchronous });
+    }
+    /**
+     * Deletes all replicas based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when deleting replicas.
+     * @param isSynchronous - Whether this mutation is synchronous.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The result of the deletion.
+     */
+    async deleteAllReplicas(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllReplicas, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
+        });
+    }
+    /**
+     * Triggers a replica to run immediately.
+     * @param id - The ID of the replica to trigger.
+     * @returns The triggered replica.
+     */
+    async triggerReplica(id) {
+        return this.mutateAndCheckError(Documents.TriggerReplica, { id: id });
+    }
+    /**
+     * Enables a replica.
+     * @param id - The ID of the replica to enable.
+     * @returns The enabled replica.
+     */
+    async enableReplica(id) {
+        return this.mutateAndCheckError(Documents.EnableReplica, { id: id });
+    }
+    /**
+     * Disables a replica.
+     * @param id - The ID of the replica to disable.
+     * @returns The disabled replica.
+     */
+    async disableReplica(id) {
+        return this.mutateAndCheckError(Documents.DisableReplica, { id: id });
+    }
+    /**
+     * Lookup a replica given its ID.
+     * @param id - ID of the replica.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The replica.
+     */
+    async getReplica(id, correlationId) {
+        return this.queryAndCheckError(Documents.GetReplica, { id: id, correlationId: correlationId });
+    }
+    /**
+     * Retrieves replicas based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when retrieving replicas.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The replicas.
+     */
+    async queryReplicas(filter, correlationId) {
+        return this.queryAndCheckError(Documents.QueryReplicas, {
+            filter: filter,
+            correlationId: correlationId,
+        });
+    }
+    /**
+     * Counts replicas based on the provided filter criteria.
+     * @param filter - The filter criteria to apply when counting replicas.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns The count of replicas.
+     */
+    async countReplicas(filter, correlationId) {
+        return this.queryAndCheckError(Documents.CountReplicas, {
+            filter: filter,
+            correlationId: correlationId,
+        });
+    }
+    /**
+     * Checks if a replica exists based on the provided filter criteria.
+     * @param filter - The filter criteria to apply.
+     * @param correlationId - The tenant correlation identifier, optional.
+     * @returns Whether the replica exists.
+     */
+    async replicaExists(filter, correlationId) {
+        return this.queryAndCheckError(Documents.ReplicaExists, {
+            filter: filter,
+            correlationId: correlationId,
+        });
+    }
+    // ──────────────────────────────────────────────────────────────────────────
     // Skills
-    // NOTE: Types (SkillInput, SkillUpdateInput, SkillFilter, etc.) and
-    // Documents (CreateSkill, UpdateSkill, etc.) will be generated by codegen
-    // once the API schema is published. Until then these methods will show
-    // TypeScript errors — that is expected.
     // ──────────────────────────────────────────────────────────────────────────
     /**
      * Creates a skill.
@@ -6752,7 +6877,6 @@ class Graphlit {
         let totalToolCalls = 0;
         let status = "completed";
         let finalMessage = "";
-        let taskCompleteSummary;
         let stuckPattern;
         let errorMessage;
         let lastContextWindow;
@@ -6855,23 +6979,24 @@ class Graphlit {
                     evaluator.adjustBudget(multiplier);
                 }
             }
-            // Build tools list with task_complete prepended
+            // Build tools list with task_complete prepended.
+            //
+            // task_complete is a bare completion signal — it takes no arguments.
+            // The agent's user-facing answer MUST be in its final assistant message
+            // (the `fullMessage` / `finalAssistantMessage` on the turn result); this
+            // tool only marks the run as done.
+            //
+            // Earlier versions had a `summary` field. That consistently caused the
+            // model to stuff its answer into the tool argument and then write a
+            // useless prose message ("answer delivered above") — the user would see
+            // the empty prose, not the answer. Removing the field eliminates the
+            // hiding place.
             const taskCompleteTool = {
                 name: "task_complete",
-                description: "Call this tool when you have completed the assigned task. Provide a summary of what was accomplished and any recommendations.",
+                description: "Signal that you have completed the assigned task. Your full answer must already be in your assistant message BEFORE calling this — that prose is what the user sees. This tool takes no arguments; it only ends the run.",
                 schema: JSON.stringify({
                     type: "object",
-                    properties: {
-                        summary: {
-                            type: "string",
-                            description: "Summary of what was accomplished.",
-                        },
-                        recommendations: {
-                            type: "string",
-                            description: "Optional recommendations or next steps.",
-                        },
-                    },
-                    required: ["summary"],
+                    properties: {},
                 }),
             };
             const allTools = [
@@ -7168,8 +7293,7 @@ class Graphlit {
                 }
                 // 9. Build TurnResult
                 const turnDuration = Date.now() - turnStart;
-                const taskCompleteInfo = this.detectTaskCompleteInMessages(loopResult.intermediateMessages);
-                const taskCompleteThisTurn = taskCompleteInfo.called;
+                const taskCompleteThisTurn = this.detectTaskCompleteInMessages(loopResult.intermediateMessages);
                 const turnToolNames = [...new Set(loopResult.toolCallNames)].sort();
                 const turnResult = {
                     turnNumber: turn,
@@ -7197,7 +7321,6 @@ class Graphlit {
                 // 11. Evaluate turn
                 // a. task_complete called?
                 if (taskCompleteThisTurn) {
-                    taskCompleteSummary = taskCompleteInfo.summary;
                     status = "completed";
                     break;
                 }
@@ -7236,9 +7359,13 @@ class Graphlit {
                 // f. Set next prompt
                 currentPrompt = "Continue.";
             }
-            // If we exited the loop without an explicit status change, check budget
+            // If we exited the loop without an explicit status change, check budget.
+            // status defaults to "completed", so we need a positive signal that
+            // task_complete was actually called — otherwise hitting the turn cap
+            // looks like success.
+            const taskCompleteWasCalled = turnResults.some((t) => t.taskComplete);
             if (status === "completed" &&
-                !taskCompleteSummary &&
+                !taskCompleteWasCalled &&
                 turnResults.length >= evaluator.adjustedMaxTurns) {
                 status = "budget_exhausted";
             }
@@ -7254,7 +7381,6 @@ class Graphlit {
                 conversationId,
                 status,
                 finalMessage,
-                taskCompleteSummary,
                 turnResults,
                 totalToolCalls,
                 wallClockMs,
@@ -7281,7 +7407,6 @@ class Graphlit {
                 conversationId,
                 status,
                 finalMessage,
-                taskCompleteSummary,
                 turnResults,
                 totalToolCalls,
                 wallClockMs: Date.now() - runStart,
@@ -7382,7 +7507,7 @@ class Graphlit {
                 toolCalls: [...new Set(toolNames)].sort(),
                 toolCallCount: toolNames.length,
                 durationMs: computePersistedToolRoundDurationMs(assistantMsg.toolCalls) ?? 0,
-                taskComplete: this.detectTaskComplete(assistantMsg.toolCalls).called,
+                taskComplete: this.detectTaskComplete(assistantMsg.toolCalls),
                 errors: toolErrors.length > 0 ? toolErrors : undefined,
             });
         }
@@ -7394,70 +7519,50 @@ class Graphlit {
      * Recognizes two invocation shapes:
      *   1. Direct — a tool call whose `name` is `"task_complete"`.
      *   2. Wrapped — a tool call whose arguments JSON has shape
-     *      `{ tool: "task_complete", parameters: { summary?, ... } }`. This is
-     *      the common pattern used by dynamic-toolset clients that expose a
-     *      single meta-executor (often named `execute_tool`) at the top level
-     *      and route every underlying tool through it.
+     *      `{ tool: "task_complete", parameters: { ... } }`. This is the common
+     *      pattern used by dynamic-toolset clients that expose a single
+     *      meta-executor (often named `execute_tool`) at the top level and
+     *      route every underlying tool through it.
      *
      * Detection is invocation-agnostic: whether the model called task_complete
-     * directly or via a meta-executor, the harness treats the turn as complete
-     * and surfaces the provided summary. Callers that only register a direct
-     * top-level task_complete still work — the wrapped path is simply inert
-     * when no meta-executor is in use.
+     * directly or via a meta-executor, the harness treats the turn as complete.
+     * Callers that only register a direct top-level task_complete still work —
+     * the wrapped path is simply inert when no meta-executor is in use.
      */
     detectTaskComplete(toolCalls) {
         if (!toolCalls)
-            return { called: false };
+            return false;
         for (const tc of toolCalls) {
             if (!tc)
                 continue;
             // Direct invocation
-            if (tc.name === "task_complete") {
-                if (!tc.arguments)
-                    return { called: true };
-                try {
-                    const args = JSON.parse(tc.arguments);
-                    return {
-                        called: true,
-                        summary: typeof args.summary === "string" ? args.summary : undefined,
-                    };
-                }
-                catch {
-                    return { called: true };
-                }
-            }
+            if (tc.name === "task_complete")
+                return true;
             // Meta-executor wrapping (e.g. execute_tool({ tool: "task_complete", parameters: {...} }))
             if (tc.arguments) {
                 try {
                     const args = JSON.parse(tc.arguments);
-                    if (args.tool === "task_complete") {
-                        const params = args.parameters ?? {};
-                        return {
-                            called: true,
-                            summary: typeof params.summary === "string" ? params.summary : undefined,
-                        };
-                    }
+                    if (args.tool === "task_complete")
+                        return true;
                 }
                 catch {
                     // Not JSON — skip
                 }
             }
         }
-        return { called: false };
+        return false;
     }
     /**
-     * Scan a list of messages for a task_complete invocation. Returns the first
-     * match found across all tool calls in all messages. Convenience wrapper
-     * over `detectTaskComplete` for the streamAgent loop, which works with
-     * `intermediateMessages` rather than a single tool-call list.
+     * Scan a list of messages for a task_complete invocation. Convenience
+     * wrapper over `detectTaskComplete` for the streamAgent loop, which works
+     * with `intermediateMessages` rather than a single tool-call list.
      */
     detectTaskCompleteInMessages(messages) {
         for (const msg of messages) {
-            const result = this.detectTaskComplete(msg.toolCalls);
-            if (result.called)
-                return result;
+            if (this.detectTaskComplete(msg.toolCalls))
+                return true;
         }
-        return { called: false };
+        return false;
     }
     /**
      * Run LLM-as-judge quality assessment on a completed agent run.
@@ -7538,7 +7643,6 @@ class Graphlit {
             conversationId: params.conversationId,
             status: params.status,
             finalMessage: params.finalMessage,
-            taskCompleteSummary: params.taskCompleteSummary,
             turns: params.turnResults.length,
             totalToolCalls: params.totalToolCalls,
             wallClockMs: params.wallClockMs,

package/dist/generated/graphql-documents.d.ts

@@ -412,6 +412,19 @@ export declare const QueryCredits: import("graphql").DocumentNode;
 export declare const QueryTokens: import("graphql").DocumentNode;
 export declare const QueryUsage: import("graphql").DocumentNode;
 export declare const UpdateProject: import("graphql").DocumentNode;
+export declare const CountReplicas: import("graphql").DocumentNode;
+export declare const CreateReplica: import("graphql").DocumentNode;
+export declare const DeleteAllReplicas: import("graphql").DocumentNode;
+export declare const DeleteReplica: import("graphql").DocumentNode;
+export declare const DeleteReplicas: import("graphql").DocumentNode;
+export declare const DisableReplica: import("graphql").DocumentNode;
+export declare const EnableReplica: import("graphql").DocumentNode;
+export declare const GetReplica: import("graphql").DocumentNode;
+export declare const QueryReplicas: import("graphql").DocumentNode;
+export declare const ReplicaExists: import("graphql").DocumentNode;
+export declare const TriggerReplica: import("graphql").DocumentNode;
+export declare const UpdateReplica: import("graphql").DocumentNode;
+export declare const UpsertReplica: import("graphql").DocumentNode;
 export declare const CountRepos: import("graphql").DocumentNode;
 export declare const CreateRepo: import("graphql").DocumentNode;
 export declare const DeleteAllRepos: import("graphql").DocumentNode;