@agentscope-ai/agentscope 0.0.2 → 0.0.4

package/src/agent/agent.test.ts

@@ -76,12 +76,14 @@ describe('Human-in-the-loop', () => {
                 id: '1',
                 name: 'Bash',
                 input: `{"command": "echo Hello"}`,
+                state: 'pending',
             },
             {
                 type: 'tool_call',
                 id: '2',
                 name: 'Bash',
                 input: `{"command": "echo World"}`,
+                state: 'pending',
             },
         ];
 
@@ -93,26 +95,26 @@ describe('Human-in-the-loop', () => {
 
         expect(lastEvent).toMatchObject({
             type: EventType.REQUIRE_USER_CONFIRM,
-            toolCalls: [
+            tool_calls: [
                 {
                     type: 'tool_call',
                     id: '1',
                     name: 'Bash',
                     input: '{"command": "echo Hello"}',
-                    awaitUserConfirmation: true,
+                    state: 'asking',
                 },
                 {
                     type: 'tool_call',
                     id: '2',
                     name: 'Bash',
                     input: '{"command": "echo World"}',
-                    awaitUserConfirmation: true,
+                    state: 'asking',
                 },
             ],
         });
 
         expect(await agent.toJSON()).toMatchObject({
-            replyId: expect.any(String),
+            reply_id: expect.any(String),
             confirmedToolCallIds: [],
             curIter: 0,
         });
@@ -126,21 +128,21 @@ describe('Human-in-the-loop', () => {
                         input: '{"command": "echo Hello"}',
                         name: 'Bash',
                         type: 'tool_call',
-                        awaitUserConfirmation: true,
+                        state: 'asking',
                     },
                     {
                         id: '2',
                         input: '{"command": "echo World"}',
                         name: 'Bash',
                         type: 'tool_call',
-                        awaitUserConfirmation: true,
+                        state: 'asking',
                     },
                 ],
                 id: expect.any(String),
                 metadata: {},
                 name: 'Friday',
                 role: 'assistant',
-                timestamp: expect.any(String),
+                created_at: expect.any(String),
             },
         ]);
 
@@ -148,17 +150,18 @@ describe('Human-in-the-loop', () => {
         for await (const event of agent.replyStream({
             event: {
                 id: 'xxx',
-                createdAt: new Date().toISOString(),
+                created_at: new Date().toISOString(),
                 type: EventType.USER_CONFIRM_RESULT,
-                replyId: agent.replyId,
-                confirmResults: [
+                reply_id: agent.replyId,
+                confirm_results: [
                     {
                         confirmed: true,
-                        toolCall: {
+                        tool_call: {
                             type: 'tool_call',
                             id: '1',
                             name: 'Bash',
                             input: '{"command": "echo Hello"}',
+                            state: 'pending',
                         },
                     },
                 ],
@@ -170,13 +173,14 @@ describe('Human-in-the-loop', () => {
         // Verify the agent still yields user confirmation for the second tool call
         expect(lastEvent).toMatchObject({
             type: EventType.REQUIRE_USER_CONFIRM,
-            replyId: expect.any(String),
-            toolCalls: [
+            reply_id: expect.any(String),
+            tool_calls: [
                 {
                     type: 'tool_call',
                     id: '2',
                     name: 'Bash',
                     input: '{"command": "echo World"}',
+                    state: 'asking',
                 },
             ],
         });
@@ -189,13 +193,14 @@ describe('Human-in-the-loop', () => {
                     input: '{"command": "echo Hello"}',
                     name: 'Bash',
                     type: 'tool_call',
+                    state: 'allowed',
                 },
                 {
                     id: '2',
                     input: '{"command": "echo World"}',
                     name: 'Bash',
                     type: 'tool_call',
-                    awaitUserConfirmation: true,
+                    state: 'asking',
                 },
                 {
                     id: '1',
@@ -219,17 +224,18 @@ describe('Human-in-the-loop', () => {
         const res = agent.replyStream({
             event: {
                 id: 'xxx',
-                createdAt: new Date().toISOString(),
+                created_at: new Date().toISOString(),
                 type: EventType.USER_CONFIRM_RESULT,
-                replyId: agent.replyId,
-                confirmResults: [
+                reply_id: agent.replyId,
+                confirm_results: [
                     {
                         confirmed: false,
-                        toolCall: {
+                        tool_call: {
                             type: 'tool_call',
                             id: '2',
                             name: 'Bash',
                             input: '{"command": "echo World"}',
+                            state: 'pending',
                         },
                     },
                 ],
@@ -249,9 +255,9 @@ describe('Human-in-the-loop', () => {
         // Verify the lastEvent
         expect(lastEvent).toMatchObject({
             id: expect.any(String),
-            type: EventType.RUN_FINISHED,
-            createdAt: expect.any(String),
-            replyId: agent.replyId,
+            type: EventType.REPLY_END,
+            created_at: expect.any(String),
+            reply_id: agent.replyId,
         });
 
         // Verify the final agent reply msg
@@ -267,7 +273,7 @@ describe('Human-in-the-loop', () => {
             metadata: {},
             name: 'Friday',
             role: 'assistant',
-            timestamp: expect.any(String),
+            created_at: expect.any(String),
         });
     });
 
@@ -312,12 +318,14 @@ describe('Human-in-the-loop', () => {
                 id: '1',
                 name: 'ExternalTool1',
                 input: `{"query": "test query"}`,
+                state: 'pending',
             },
             {
                 type: 'tool_call',
                 id: '2',
                 name: 'ExternalTool2',
                 input: `{"data": "test data"}`,
+                state: 'pending',
             },
         ];
 
@@ -330,25 +338,27 @@ describe('Human-in-the-loop', () => {
         // Verify the agent emits REQUIRE_EXTERNAL_EXECUTION event
         expect(lastEvent).toMatchObject({
             type: EventType.REQUIRE_EXTERNAL_EXECUTION,
-            toolCalls: [
+            tool_calls: [
                 {
                     type: 'tool_call',
                     id: '1',
                     name: 'ExternalTool1',
                     input: '{"query": "test query"}',
+                    state: 'pending',
                 },
                 {
                     type: 'tool_call',
                     id: '2',
                     name: 'ExternalTool2',
                     input: '{"data": "test data"}',
+                    state: 'pending',
                 },
             ],
         });
 
         // Verify agent state
         expect(await agent.toJSON()).toMatchObject({
-            replyId: expect.any(String),
+            reply_id: expect.any(String),
             confirmedToolCallIds: [],
             curIter: 0,
         });
@@ -362,19 +372,22 @@ describe('Human-in-the-loop', () => {
                         input: '{"query": "test query"}',
                         name: 'ExternalTool1',
                         type: 'tool_call',
+                        state: 'pending',
                     },
                     {
                         id: '2',
                         input: '{"data": "test data"}',
                         name: 'ExternalTool2',
                         type: 'tool_call',
+                        state: 'pending',
                     },
                 ],
                 id: expect.any(String),
                 metadata: {},
                 name: 'Friday',
                 role: 'assistant',
-                timestamp: expect.any(String),
+                created_at: expect.any(String),
+                finished_at: undefined,
             },
         ]);
 
@@ -382,10 +395,10 @@ describe('Human-in-the-loop', () => {
         for await (const event of agent.replyStream({
             event: {
                 id: 'xxx',
-                createdAt: new Date().toISOString(),
+                created_at: new Date().toISOString(),
                 type: EventType.EXTERNAL_EXECUTION_RESULT,
-                replyId: agent.replyId,
-                executionResults: [
+                reply_id: agent.replyId,
+                execution_results: [
                     {
                         type: 'tool_result',
                         id: '1',
@@ -408,13 +421,14 @@ describe('Human-in-the-loop', () => {
         // Verify the agent still requires external execution for the second tool
         expect(lastEvent).toMatchObject({
             type: EventType.REQUIRE_EXTERNAL_EXECUTION,
-            replyId: expect.any(String),
-            toolCalls: [
+            reply_id: expect.any(String),
+            tool_calls: [
                 {
                     type: 'tool_call',
                     id: '2',
                     name: 'ExternalTool2',
                     input: '{"data": "test data"}',
+                    state: 'pending',
                 },
             ],
         });
@@ -427,12 +441,14 @@ describe('Human-in-the-loop', () => {
                     input: '{"query": "test query"}',
                     name: 'ExternalTool1',
                     type: 'tool_call',
+                    state: 'pending',
                 },
                 {
                     id: '2',
                     input: '{"data": "test data"}',
                     name: 'ExternalTool2',
                     type: 'tool_call',
+                    state: 'pending',
                 },
                 {
                     id: '1',
@@ -456,10 +472,10 @@ describe('Human-in-the-loop', () => {
         const res = agent.replyStream({
             event: {
                 id: 'xxx',
-                createdAt: new Date().toISOString(),
+                created_at: new Date().toISOString(),
                 type: EventType.EXTERNAL_EXECUTION_RESULT,
-                replyId: agent.replyId,
-                executionResults: [
+                reply_id: agent.replyId,
+                execution_results: [
                     {
                         type: 'tool_result',
                         id: '2',
@@ -490,9 +506,9 @@ describe('Human-in-the-loop', () => {
         // Verify the lastEvent is RUN_FINISHED
         expect(lastEvent).toMatchObject({
             id: expect.any(String),
-            type: EventType.RUN_FINISHED,
-            createdAt: expect.any(String),
-            replyId: agent.replyId,
+            type: EventType.REPLY_END,
+            created_at: expect.any(String),
+            reply_id: agent.replyId,
         });
 
         // Verify the final agent reply msg
@@ -508,7 +524,7 @@ describe('Human-in-the-loop', () => {
             metadata: {},
             name: 'Friday',
             role: 'assistant',
-            timestamp: expect.any(String),
+            created_at: expect.any(String),
         });
     });
 
@@ -578,18 +594,21 @@ describe('Human-in-the-loop', () => {
                 id: '1',
                 name: 'ExternalTool',
                 input: `{"query": "external query"}`,
+                state: 'pending',
             },
             {
                 type: 'tool_call',
                 id: '2',
                 name: 'ConfirmTool',
                 input: `{"action": "delete file"}`,
+                state: 'pending',
             },
             {
                 type: 'tool_call',
                 id: '3',
                 name: 'NormalTool',
                 input: `{"data": "normal data"}`,
+                state: 'pending',
             },
         ];
 
@@ -602,19 +621,20 @@ describe('Human-in-the-loop', () => {
         // Verify the agent emits REQUIRE_EXTERNAL_EXECUTION event for the first tool
         expect(lastEvent).toMatchObject({
             type: EventType.REQUIRE_EXTERNAL_EXECUTION,
-            toolCalls: [
+            tool_calls: [
                 {
                     type: 'tool_call',
                     id: '1',
                     name: 'ExternalTool',
                     input: '{"query": "external query"}',
+                    state: 'pending',
                 },
             ],
         });
 
         // Verify agent state
         expect(await agent.toJSON()).toMatchObject({
-            replyId: expect.any(String),
+            reply_id: expect.any(String),
             confirmedToolCallIds: [],
             curIter: 0,
         });
@@ -623,10 +643,10 @@ describe('Human-in-the-loop', () => {
         for await (const event of agent.replyStream({
             event: {
                 id: 'xxx',
-                createdAt: new Date().toISOString(),
+                created_at: new Date().toISOString(),
                 type: EventType.EXTERNAL_EXECUTION_RESULT,
-                replyId: agent.replyId,
-                executionResults: [
+                reply_id: agent.replyId,
+                execution_results: [
                     {
                         type: 'tool_result',
                         id: '1',
@@ -649,21 +669,21 @@ describe('Human-in-the-loop', () => {
         // Verify the agent now requires user confirmation for the second tool
         expect(lastEvent).toMatchObject({
             type: EventType.REQUIRE_USER_CONFIRM,
-            replyId: expect.any(String),
-            toolCalls: [
+            reply_id: expect.any(String),
+            tool_calls: [
                 {
                     type: 'tool_call',
                     id: '2',
                     name: 'ConfirmTool',
                     input: '{"action": "delete file"}',
-                    awaitUserConfirmation: true,
+                    state: 'asking',
                 },
             ],
         });
 
         // Verify agent state after external execution
         expect(await agent.toJSON()).toMatchObject({
-            replyId: expect.any(String),
+            reply_id: expect.any(String),
             confirmedToolCallIds: [],
             curIter: 0,
         });
@@ -681,17 +701,18 @@ describe('Human-in-the-loop', () => {
         for await (const event of agent.replyStream({
             event: {
                 id: 'xxx',
-                createdAt: new Date().toISOString(),
+                created_at: new Date().toISOString(),
                 type: EventType.USER_CONFIRM_RESULT,
-                replyId: agent.replyId,
-                confirmResults: [
+                reply_id: agent.replyId,
+                confirm_results: [
                     {
                         confirmed: true,
-                        toolCall: {
+                        tool_call: {
                             type: 'tool_call',
                             id: '2',
                             name: 'ConfirmTool',
                             input: '{"action": "delete file"}',
+                            state: 'pending',
                         },
                     },
                 ],
@@ -703,9 +724,9 @@ describe('Human-in-the-loop', () => {
         // Verify the lastEvent is RUN_FINISHED
         expect(lastEvent).toMatchObject({
             id: expect.any(String),
-            type: EventType.RUN_FINISHED,
-            createdAt: expect.any(String),
-            replyId: agent.replyId,
+            type: EventType.REPLY_END,
+            created_at: expect.any(String),
+            reply_id: agent.replyId,
         });
 
         // Verify the agent context includes all three tool calls, their results, and the final text
@@ -716,18 +737,21 @@ describe('Human-in-the-loop', () => {
                     input: '{"query": "external query"}',
                     name: 'ExternalTool',
                     type: 'tool_call',
+                    state: 'pending',
                 },
                 {
                     id: '2',
                     input: '{"action": "delete file"}',
                     name: 'ConfirmTool',
                     type: 'tool_call',
+                    state: 'allowed',
                 },
                 {
                     id: '3',
                     input: '{"data": "normal data"}',
                     name: 'NormalTool',
                     type: 'tool_call',
+                    state: 'pending',
                 },
                 {
                     id: '1',
@@ -823,12 +847,14 @@ describe('Human-in-the-loop', () => {
                 id: '1',
                 name: 'ExternalAndConfirmTool',
                 input: `{"command": "rm -rf /"}`,
+                state: 'pending',
             },
             {
                 type: 'tool_call',
                 id: '2',
                 name: 'ConfirmOnlyTool',
                 input: `{"action": "delete database"}`,
+                state: 'pending',
             },
         ];
 
@@ -841,27 +867,27 @@ describe('Human-in-the-loop', () => {
         // Verify the agent emits REQUIRE_USER_CONFIRM event for both tools
         expect(lastEvent).toMatchObject({
             type: EventType.REQUIRE_USER_CONFIRM,
-            toolCalls: [
+            tool_calls: [
                 {
                     type: 'tool_call',
                     id: '1',
                     name: 'ExternalAndConfirmTool',
                     input: '{"command": "rm -rf /"}',
-                    awaitUserConfirmation: true,
+                    state: 'asking',
                 },
                 {
                     type: 'tool_call',
                     id: '2',
                     name: 'ConfirmOnlyTool',
                     input: '{"action": "delete database"}',
-                    awaitUserConfirmation: true,
+                    state: 'asking',
                 },
             ],
         });
 
         // Verify agent state
         expect(await agent.toJSON()).toMatchObject({
-            replyId: expect.any(String),
+            reply_id: expect.any(String),
             confirmedToolCallIds: [],
             curIter: 0,
         });
@@ -870,26 +896,28 @@ describe('Human-in-the-loop', () => {
         for await (const event of agent.replyStream({
             event: {
                 id: 'xxx',
-                createdAt: new Date().toISOString(),
+                created_at: new Date().toISOString(),
                 type: EventType.USER_CONFIRM_RESULT,
-                replyId: agent.replyId,
-                confirmResults: [
+                reply_id: agent.replyId,
+                confirm_results: [
                     {
                         confirmed: true,
-                        toolCall: {
+                        tool_call: {
                             type: 'tool_call',
                             id: '1',
                             name: 'ExternalAndConfirmTool',
                             input: '{"command": "rm -rf /"}',
+                            state: 'pending',
                         },
                     },
                     {
                         confirmed: true,
-                        toolCall: {
+                        tool_call: {
                             type: 'tool_call',
                             id: '2',
                             name: 'ConfirmOnlyTool',
                             input: '{"action": "delete database"}',
+                            state: 'pending',
                         },
                     },
                 ],
@@ -901,20 +929,21 @@ describe('Human-in-the-loop', () => {
         // After user confirmation, the first tool requires external execution
         expect(lastEvent).toMatchObject({
             type: EventType.REQUIRE_EXTERNAL_EXECUTION,
-            replyId: expect.any(String),
-            toolCalls: [
+            reply_id: expect.any(String),
+            tool_calls: [
                 {
                     type: 'tool_call',
                     id: '1',
                     name: 'ExternalAndConfirmTool',
                     input: '{"command": "rm -rf /"}',
+                    state: 'allowed',
                 },
             ],
         });
 
         // Verify agent state after user confirmation
         expect(await agent.toJSON()).toMatchObject({
-            replyId: expect.any(String),
+            reply_id: expect.any(String),
             confirmedToolCallIds: ['1', '2'],
             curIter: 0,
         });
@@ -927,12 +956,14 @@ describe('Human-in-the-loop', () => {
                     input: '{"command": "rm -rf /"}',
                     name: 'ExternalAndConfirmTool',
                     type: 'tool_call',
+                    state: 'allowed',
                 },
                 {
                     id: '2',
                     input: '{"action": "delete database"}',
                     name: 'ConfirmOnlyTool',
                     type: 'tool_call',
+                    state: 'allowed',
                 },
             ],
         ]);
@@ -944,10 +975,10 @@ describe('Human-in-the-loop', () => {
         for await (const event of agent.replyStream({
             event: {
                 id: 'xxx',
-                createdAt: new Date().toISOString(),
+                created_at: new Date().toISOString(),
                 type: EventType.EXTERNAL_EXECUTION_RESULT,
-                replyId: agent.replyId,
-                executionResults: [
+                reply_id: agent.replyId,
+                execution_results: [
                     {
                         type: 'tool_result',
                         id: '1',
@@ -971,9 +1002,9 @@ describe('Human-in-the-loop', () => {
         // because it was already confirmed in the previous step
         expect(lastEvent).toMatchObject({
             id: expect.any(String),
-            type: EventType.RUN_FINISHED,
-            createdAt: expect.any(String),
-            replyId: agent.replyId,
+            type: EventType.REPLY_END,
+            created_at: expect.any(String),
+            reply_id: agent.replyId,
         });
 
         // Verify the final agent context includes all tool calls, their results, and the final text
@@ -984,12 +1015,14 @@ describe('Human-in-the-loop', () => {
                     input: '{"command": "rm -rf /"}',
                     name: 'ExternalAndConfirmTool',
                     type: 'tool_call',
+                    state: 'allowed',
                 },
                 {
                     id: '2',
                     input: '{"action": "delete database"}',
                     name: 'ConfirmOnlyTool',
                     type: 'tool_call',
+                    state: 'allowed',
                 },
                 {
                     id: '1',