temporalio-microsoft-agent-framework 0.0.1__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- temporalio/microsoft_agent_framework/__init__.py +67 -0
- temporalio/microsoft_agent_framework/_activities.py +403 -0
- temporalio/microsoft_agent_framework/_chat_client.py +226 -0
- temporalio/microsoft_agent_framework/_mcp.py +339 -0
- temporalio/microsoft_agent_framework/_plugin.py +294 -0
- temporalio/microsoft_agent_framework/_serde.py +578 -0
- temporalio/microsoft_agent_framework/_workflow_runtime.py +221 -0
- temporalio/microsoft_agent_framework/py.typed +1 -0
- temporalio/microsoft_agent_framework/testing.py +193 -0
- temporalio/microsoft_agent_framework/workflow.py +213 -0
- temporalio_microsoft_agent_framework-0.0.1.dist-info/METADATA +539 -0
- temporalio_microsoft_agent_framework-0.0.1.dist-info/RECORD +14 -0
- temporalio_microsoft_agent_framework-0.0.1.dist-info/WHEEL +4 -0
- temporalio_microsoft_agent_framework-0.0.1.dist-info/licenses/LICENSE +21 -0
|
@@ -0,0 +1,539 @@
|
|
|
1
|
+
Metadata-Version: 2.4
|
|
2
|
+
Name: temporalio-microsoft-agent-framework
|
|
3
|
+
Version: 0.0.1
|
|
4
|
+
Summary: Temporal integration for Microsoft Agent Framework
|
|
5
|
+
Author: Temporal Technologies Inc
|
|
6
|
+
Author-email: Temporal Technologies Inc <sdk@temporal.io>
|
|
7
|
+
License-Expression: MIT
|
|
8
|
+
License-File: LICENSE
|
|
9
|
+
Classifier: Development Status :: 3 - Alpha
|
|
10
|
+
Classifier: Programming Language :: Python :: 3.11
|
|
11
|
+
Classifier: Programming Language :: Python :: 3.12
|
|
12
|
+
Classifier: Programming Language :: Python :: 3.13
|
|
13
|
+
Classifier: Programming Language :: Python :: 3.14
|
|
14
|
+
Classifier: Programming Language :: Python :: 3.15
|
|
15
|
+
Classifier: Typing :: Typed
|
|
16
|
+
Requires-Dist: temporalio>=1.36.0,<2
|
|
17
|
+
Requires-Dist: agent-framework-core>=1.23.0,<2
|
|
18
|
+
Requires-Dist: pydantic>=2,<3
|
|
19
|
+
Requires-Dist: opentelemetry-api>=1.40.0,<2
|
|
20
|
+
Requires-Dist: temporalio-mcp>=0.4.0,<0.5 ; extra == 'mcp'
|
|
21
|
+
Requires-Dist: mcp>=2.2,<3 ; extra == 'mcp'
|
|
22
|
+
Requires-Dist: mcp-types>=2,<3 ; extra == 'mcp'
|
|
23
|
+
Requires-Python: >=3.11
|
|
24
|
+
Project-URL: Homepage, https://github.com/temporalio/ai-integrations/tree/main/python/microsoft_agent_framework
|
|
25
|
+
Project-URL: Repository, https://github.com/temporalio/ai-integrations
|
|
26
|
+
Project-URL: Documentation, https://docs.temporal.io/develop/python/integrations/microsoft-agent-framework
|
|
27
|
+
Provides-Extra: mcp
|
|
28
|
+
Description-Content-Type: text/markdown
|
|
29
|
+
|
|
30
|
+
# Microsoft Agent Framework
|
|
31
|
+
|
|
32
|
+
> Release stage: **Pre-release**.
|
|
33
|
+
|
|
34
|
+
This Temporal [Plugin](https://docs.temporal.io/develop/plugins-guide) runs a [Microsoft Agent Framework](https://github.com/microsoft/agent-framework) `Agent` inside a Temporal Workflow. Each model round trip runs as a Temporal Activity with its own timeout and retries. The agent's own function-invocation loop, tools, middleware, context providers and approvals run in the Workflow, where Temporal records every step and replays it after a crash or a worker restart. You keep writing the agent the way Agent Framework documents it; the one change is the chat client.
|
|
35
|
+
|
|
36
|
+
## Installation
|
|
37
|
+
|
|
38
|
+
```sh
|
|
39
|
+
uv add temporalio-microsoft-agent-framework
|
|
40
|
+
```
|
|
41
|
+
|
|
42
|
+
The plugin depends on `agent-framework-core` (1.23.0 or newer, below 2). The tested range, 1.23.0 through 1.24.0, runs from the floor the plugin was first tested on through the version `uv.lock` pins, which CI runs on every change; a test keeps the upper bound equal to the lock, so a lock bump moves the range and this sentence in the same PR. Add the provider package you use, for example `agent-framework-openai`. Replay safety rests on a few private names of the framework, so a worker or replayer fails at start with a message naming the name and the tested range if a release moves one of them.
|
|
43
|
+
|
|
44
|
+
## Quickstart
|
|
45
|
+
|
|
46
|
+
`workflow.py` holds the workflow. It imports nothing from the provider: the sandbox loads this file for every workflow run, and the OpenAI SDK's import tree trips its restrictions, so a provider import here fails the worker at start.
|
|
47
|
+
|
|
48
|
+
```python
|
|
49
|
+
from datetime import timedelta
|
|
50
|
+
|
|
51
|
+
from agent_framework import Agent
|
|
52
|
+
from temporalio import workflow
|
|
53
|
+
from temporalio.microsoft_agent_framework import TemporalChatClient
|
|
54
|
+
|
|
55
|
+
|
|
56
|
+
@workflow.defn
|
|
57
|
+
class HelloWorkflow:
|
|
58
|
+
@workflow.run
|
|
59
|
+
async def run(self, prompt: str) -> str:
|
|
60
|
+
agent = Agent(
|
|
61
|
+
client=TemporalChatClient("gpt-4o", start_to_close_timeout=timedelta(seconds=60)),
|
|
62
|
+
instructions="You are a concise assistant.",
|
|
63
|
+
)
|
|
64
|
+
response = await agent.run(prompt)
|
|
65
|
+
return response.text
|
|
66
|
+
```
|
|
67
|
+
|
|
68
|
+
`worker.py` builds the provider client in a factory and runs the worker. The plugin goes on `Client.connect(...)`: the Worker inherits it, and the Client gets the plugin's data converter, which a plugin on the Worker alone cannot set.
|
|
69
|
+
|
|
70
|
+
```python
|
|
71
|
+
import asyncio
|
|
72
|
+
|
|
73
|
+
from agent_framework.openai import OpenAIChatClient
|
|
74
|
+
from openai import AsyncOpenAI
|
|
75
|
+
from temporalio.client import Client
|
|
76
|
+
from temporalio.microsoft_agent_framework import MicrosoftAgentFrameworkPlugin
|
|
77
|
+
from temporalio.worker import Worker
|
|
78
|
+
|
|
79
|
+
from workflow import HelloWorkflow
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
def gpt_4o() -> OpenAIChatClient:
|
|
83
|
+
return OpenAIChatClient(model="gpt-4o", async_client=AsyncOpenAI(max_retries=0))
|
|
84
|
+
|
|
85
|
+
|
|
86
|
+
plugin = MicrosoftAgentFrameworkPlugin(chat_clients={"gpt-4o": gpt_4o})
|
|
87
|
+
|
|
88
|
+
|
|
89
|
+
async def main() -> None:
|
|
90
|
+
client = await Client.connect("localhost:7233", plugins=[plugin])
|
|
91
|
+
worker = Worker(client, task_queue="microsoft-agent-framework", workflows=[HelloWorkflow])
|
|
92
|
+
await worker.run()
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
if __name__ == "__main__":
|
|
96
|
+
asyncio.run(main())
|
|
97
|
+
```
|
|
98
|
+
|
|
99
|
+
`client.py` starts the workflow. The starter's Client carries the plugin too, so its data converter matches the worker's.
|
|
100
|
+
|
|
101
|
+
```python
|
|
102
|
+
import asyncio
|
|
103
|
+
|
|
104
|
+
from temporalio.client import Client
|
|
105
|
+
from temporalio.microsoft_agent_framework import MicrosoftAgentFrameworkPlugin
|
|
106
|
+
|
|
107
|
+
from workflow import HelloWorkflow
|
|
108
|
+
|
|
109
|
+
|
|
110
|
+
async def main() -> None:
|
|
111
|
+
client = await Client.connect("localhost:7233", plugins=[MicrosoftAgentFrameworkPlugin()])
|
|
112
|
+
result = await client.execute_workflow(
|
|
113
|
+
HelloWorkflow.run,
|
|
114
|
+
"Hello",
|
|
115
|
+
id="microsoft-agent-framework-quickstart",
|
|
116
|
+
task_queue="microsoft-agent-framework",
|
|
117
|
+
)
|
|
118
|
+
print(result)
|
|
119
|
+
|
|
120
|
+
|
|
121
|
+
if __name__ == "__main__":
|
|
122
|
+
asyncio.run(main())
|
|
123
|
+
```
|
|
124
|
+
|
|
125
|
+
The `AsyncOpenAI` client built in the factory reads `OPENAI_API_KEY` on the worker. The workflow only carries the name `"gpt-4o"`.
|
|
126
|
+
|
|
127
|
+
What runs where: the `Agent`, its loop, your tools, middleware, context providers and approval handling run in the Workflow. Each provider round trip runs as the `microsoft_agent_framework.invoke_model` Activity (`microsoft_agent_framework.invoke_model_streaming` when you stream). The messages and chat options cross to the Activity in their `to_dict()` form, tools cross as their JSON schema specs, and the `ChatResponse` comes back the same way; provider SDK objects (`raw_representation`) never enter history.
|
|
128
|
+
|
|
129
|
+
## Chat clients and credentials
|
|
130
|
+
|
|
131
|
+
`MicrosoftAgentFrameworkPlugin(chat_clients=...)` maps a model name to a factory that builds the provider's chat client. The factory runs on the worker, on first use, and its client is cached for the worker's lifetime, so credentials and connections stay on the worker. `TemporalChatClient("name")` in the workflow selects the factory and carries the activity options for that agent's model calls. Register as many names as you have models:
|
|
132
|
+
|
|
133
|
+
```python
|
|
134
|
+
from agent_framework.openai import OpenAIChatClient
|
|
135
|
+
from openai import AsyncOpenAI
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
@workflow.defn
|
|
139
|
+
class TwoModelWorkflow:
|
|
140
|
+
@workflow.run
|
|
141
|
+
async def run(self, prompt: str) -> str:
|
|
142
|
+
fast = Agent(client=TemporalChatClient("fast"), instructions="Draft.")
|
|
143
|
+
careful = Agent(client=TemporalChatClient("careful"), instructions="Review the draft.")
|
|
144
|
+
draft = await fast.run(prompt)
|
|
145
|
+
return (await careful.run(draft.text)).text
|
|
146
|
+
|
|
147
|
+
|
|
148
|
+
CHAT_CLIENTS = {
|
|
149
|
+
"fast": lambda: OpenAIChatClient(
|
|
150
|
+
model="gpt-4o-mini", async_client=AsyncOpenAI(max_retries=0)
|
|
151
|
+
),
|
|
152
|
+
"careful": lambda: OpenAIChatClient(
|
|
153
|
+
model="gpt-4o", async_client=AsyncOpenAI(max_retries=0)
|
|
154
|
+
),
|
|
155
|
+
}
|
|
156
|
+
plugin = MicrosoftAgentFrameworkPlugin(chat_clients=CHAT_CLIENTS)
|
|
157
|
+
```
|
|
158
|
+
|
|
159
|
+
A name the worker does not know fails the Activity with a non-retryable `ApplicationError` of type `MicrosoftAgentFrameworkUnknownChatClient`, so the workflow fails instead of waiting. A factory that raises (for example `OpenAIChatClient` without `OPENAI_API_KEY` on the worker, or a secret store that is down for a moment) fails the attempt with a retryable `ApplicationError` of type `MicrosoftAgentFrameworkChatClientFactoryError`, logged at ERROR on the worker with the cause, so the call's `retry_policy` or `schedule_to_close_timeout` bounds the wait and another worker on the task queue can pick the attempt up; a factory that returns `None` is wrong on every attempt and fails the Activity non-retryably with the same type. Headers for hosted MCP tools stay on the worker too, in `hosted_mcp_headers` (see Tools). During a rolling deployment, add the name to every worker on the task queue before workflows start using it.
|
|
160
|
+
|
|
161
|
+
`TemporalChatClient("gpt-4o").as_agent(instructions=..., tools=...)` is the short form of `Agent(client=TemporalChatClient("gpt-4o"), ...)`. Calling a `TemporalChatClient` outside a workflow raises `RuntimeError`; use the provider's client there.
|
|
162
|
+
|
|
163
|
+
A run's `client_kwargs`, such as `extra_headers` for the OpenAI client, cross to the Activity and reach the provider client. They are recorded in Event History, so secrets stay in the factory: an `extra_headers` entry named `authorization`, `x-api-key` or `api-key` (in any case) fails the workflow with `MicrosoftAgentFrameworkWorkflowError`, the same rule as for hosted MCP headers; put such a header on the provider client, for example `AsyncOpenAI(default_headers=...)`. A value that is not JSON-compatible fails the workflow the same way.
|
|
164
|
+
|
|
165
|
+
## Retries and timeouts
|
|
166
|
+
|
|
167
|
+
Each `TemporalChatClient` carries the activity options of its model calls: `start_to_close_timeout` (default 5 minutes), `heartbeat_timeout` (default 10 seconds; the Activity heartbeats on its own at half that interval, so a dead worker is noticed within seconds), `schedule_to_close_timeout`, `retry_policy`, `task_queue`, `summary` (defaults to the model name), `schedule_to_start_timeout`, `cancellation_type`, `versioning_intent` and `priority`. Give reasoning models a longer `start_to_close_timeout`.
|
|
168
|
+
|
|
169
|
+
```python
|
|
170
|
+
from temporalio.common import RetryPolicy
|
|
171
|
+
|
|
172
|
+
chat_client = TemporalChatClient(
|
|
173
|
+
"gpt-4o",
|
|
174
|
+
start_to_close_timeout=timedelta(minutes=10),
|
|
175
|
+
retry_policy=RetryPolicy(maximum_attempts=3),
|
|
176
|
+
)
|
|
177
|
+
```
|
|
178
|
+
|
|
179
|
+
Temporal owns retries, so turn the provider SDK's own retries off: `OpenAIChatClient` does not expose `max_retries`, so pass `async_client=AsyncOpenAI(max_retries=0)` as the quickstart does. A factory whose client still retries (`max_retries > 0`) gets one warning in the worker log the first time it runs.
|
|
180
|
+
|
|
181
|
+
Provider errors are classified by HTTP status. Agent Framework wraps the SDK error in `ChatClientException`; the Activity walks the cause chain for a `status_code`. 408, 409, 429 and 5xx stay retryable and honor `retry-after-ms`, `retry-after` and `x-should-retry` headers through the next retry delay; other 4xx are non-retryable; errors without a status (connection failures) stay retryable. `retry-after-ms` and `retry-after` parse as numbers, fractions included, or as an HTTP-date; a value that does not parse falls through to the next form; a hint above 60 seconds is capped at 60 seconds, and a past date leaves the retry policy's own backoff in charge. The failure reaches the workflow as an `ActivityError` whose cause is an `ApplicationError` with `type` set to the SDK's exception class name, for example `RateLimitError` or `AuthenticationError`. Match on `type`, not on the message.
|
|
182
|
+
|
|
183
|
+
## Tools
|
|
184
|
+
|
|
185
|
+
Decide per tool where it runs. Pure logic stays in the Workflow as a plain `@tool`; anything that does I/O or reads a clock belongs in an Activity. The plugin cannot tell them apart, so the choice is yours: decorate the I/O function with `@activity.defn`, register it on the worker, and pass it to the agent with `activity_as_tool`:
|
|
186
|
+
|
|
187
|
+
```python
|
|
188
|
+
from agent_framework import tool
|
|
189
|
+
from temporalio import activity
|
|
190
|
+
from temporalio.microsoft_agent_framework.workflow import activity_as_tool
|
|
191
|
+
|
|
192
|
+
|
|
193
|
+
@activity.defn
|
|
194
|
+
async def fetch_user(user_id: str) -> dict:
|
|
195
|
+
"""Fetch a user record."""
|
|
196
|
+
...
|
|
197
|
+
|
|
198
|
+
|
|
199
|
+
@tool
|
|
200
|
+
def shout(text: str) -> str:
|
|
201
|
+
"""Upper-case the text."""
|
|
202
|
+
return text.upper()
|
|
203
|
+
|
|
204
|
+
|
|
205
|
+
@workflow.defn
|
|
206
|
+
class ToolsWorkflow:
|
|
207
|
+
@workflow.run
|
|
208
|
+
async def run(self, prompt: str) -> str:
|
|
209
|
+
agent = Agent(
|
|
210
|
+
client=TemporalChatClient("gpt-4o"),
|
|
211
|
+
tools=[
|
|
212
|
+
shout,
|
|
213
|
+
activity_as_tool(fetch_user, start_to_close_timeout=timedelta(seconds=30)),
|
|
214
|
+
],
|
|
215
|
+
)
|
|
216
|
+
return (await agent.run(prompt)).text
|
|
217
|
+
|
|
218
|
+
|
|
219
|
+
async def run_worker() -> None:
|
|
220
|
+
client = await Client.connect("localhost:7233", plugins=[plugin])
|
|
221
|
+
worker = Worker(
|
|
222
|
+
client,
|
|
223
|
+
task_queue="microsoft-agent-framework",
|
|
224
|
+
workflows=[ToolsWorkflow],
|
|
225
|
+
activities=[fetch_user],
|
|
226
|
+
)
|
|
227
|
+
await worker.run()
|
|
228
|
+
```
|
|
229
|
+
|
|
230
|
+
`activity_as_tool` takes a function or a method passed as `Class.method` (register the bound method on the worker). Agent Framework infers the tool's parameter schema from the activity's signature, so `Annotated[str, "description"]` parameters and docstrings work as they do for `@tool`. The arguments bind by name and reach the activity by position. `approval_mode="always_require"` works on an activity tool like on any other. A failed activity, including one whose retries ran out, raises its failure cause from the tool, which Agent Framework turns into an error result for the model; cancellation propagates as `asyncio.CancelledError`. Like `workflow.execute_activity`, `activity_as_tool` needs `start_to_close_timeout` or `schedule_to_close_timeout`; without either it raises `ValueError` when the tool is built, not when the model calls it. Agent Framework's loop settings apply unchanged: tool calls of one response run concurrently by default (`allow_concurrent_invocation=True`), a run makes at most `max_iterations` (40) model calls before one last call with `tool_choice="none"`, and after three consecutive rounds of failing tools the loop stops calling tools and asks for a final answer. Set them on `TemporalChatClient(function_invocation_configuration={...})`.
|
|
231
|
+
|
|
232
|
+
Synchronous `def` tools run inline on the workflow task. Agent Framework hands a `def` tool to `asyncio.to_thread`, which the workflow event loop does not implement, so the plugin's worker runtime rebinds that name in the framework's tool module to a stand-in that calls the function directly inside a workflow and still uses a thread anywhere else. The tool object itself is not changed, so one shared with an Activity or a plain agent in the same process keeps its normal behavior there. A tool that blocks for long blocks the workflow task, so keep sync tools quick.
|
|
233
|
+
|
|
234
|
+
Declaration-only tools (`FunctionTool(func=None, ...)`) are advertised to the model and the run returns the model's call to you, as in Agent Framework. Hosted tools passed as mappings, such as the provider's web search, pass through to the model Activity and run on the provider's side. A hosted MCP tool (`OpenAIChatClient.get_mcp_tool(...)`) must not carry `headers` or `authorization` in workflow code: the mapping is recorded in history, so the run fails with `MicrosoftAgentFrameworkWorkflowError`. Register the headers on the worker instead, with `MicrosoftAgentFrameworkPlugin(hosted_mcp_headers={"github": {"Authorization": "Bearer ..."}})` keyed by the server label or URL (a callable returning the headers works too); the Activity adds them to the tool before the provider call. For an OpenAI connector (a mapping with `connector_id`), an entry named `authorization` (any case) in that mapping is applied to the tool's `authorization` field, where the Responses API takes a connector's OAuth token as the bare token, so a leading `Bearer ` is dropped from that one entry; the other entries stay headers and are passed as written. `agent.as_tool()` works unchanged: the sub-agent's model calls run as Activities in the same workflow.
|
|
235
|
+
|
|
236
|
+
A tool object the plugin cannot send to the model (anything that is not a `FunctionTool`, a `@tool` function or a mapping) fails the workflow with `MicrosoftAgentFrameworkWorkflowError`.
|
|
237
|
+
|
|
238
|
+
## MCP
|
|
239
|
+
|
|
240
|
+
MCP support runs on [`temporalio-mcp`](https://github.com/temporalio/ai-integrations/tree/main/python/mcp) and the MCP Python SDK v2. Install it with the `mcp` extra:
|
|
241
|
+
|
|
242
|
+
```sh
|
|
243
|
+
uv add "temporalio-microsoft-agent-framework[mcp]"
|
|
244
|
+
```
|
|
245
|
+
|
|
246
|
+
`MicrosoftAgentFrameworkPlugin(mcp_clients=...)` maps a server name to a factory returning an `mcp.Client`, the same shape as `chat_clients`. A factory that raises fails the attempt with a retryable `ApplicationError` of type `MicrosoftAgentFrameworkMCPClientFactoryError`, logged at ERROR on the worker, under the same rule as the chat client factories; one that returns something other than an `mcp.Client` fails the Activity non-retryably with the same type. The plugin registers the `temporalio.mcp.{name}.list-tools` and `temporalio.mcp.{name}.call-tool` Activities (and the other `temporalio-mcp` operations) for each server. Workflow-side, `TemporalMCPToolProvider("name")` is a context provider: before each agent run it lists the server's tools and adds one `FunctionTool` per tool, with the server's full input schema, whose call runs the `call-tool` Activity. It goes in `context_providers`, not `tools`, because Agent Framework drives an `MCPTool` in `tools=` through a live connection that cannot exist in a workflow; a context provider is the framework's public way to add tools to a run.
|
|
247
|
+
|
|
248
|
+
```python
|
|
249
|
+
from mcp import Client as MCPClient
|
|
250
|
+
from mcp import StdioServerParameters, stdio_client
|
|
251
|
+
from temporalio.microsoft_agent_framework import TemporalMCPToolProvider
|
|
252
|
+
|
|
253
|
+
|
|
254
|
+
@workflow.defn
|
|
255
|
+
class MCPWorkflow:
|
|
256
|
+
@workflow.run
|
|
257
|
+
async def run(self, prompt: str) -> str:
|
|
258
|
+
agent = Agent(
|
|
259
|
+
client=TemporalChatClient("gpt-4o"),
|
|
260
|
+
context_providers=[
|
|
261
|
+
TemporalMCPToolProvider("echo", start_to_close_timeout=timedelta(seconds=30))
|
|
262
|
+
],
|
|
263
|
+
)
|
|
264
|
+
return (await agent.run(prompt)).text
|
|
265
|
+
|
|
266
|
+
|
|
267
|
+
# worker
|
|
268
|
+
plugin = MicrosoftAgentFrameworkPlugin(
|
|
269
|
+
chat_clients=CHAT_CLIENTS,
|
|
270
|
+
mcp_clients={
|
|
271
|
+
"echo": lambda: MCPClient(
|
|
272
|
+
stdio_client(StdioServerParameters(command="python", args=["echo_server.py"]))
|
|
273
|
+
),
|
|
274
|
+
},
|
|
275
|
+
)
|
|
276
|
+
```
|
|
277
|
+
|
|
278
|
+
`cache_tools=False` (the default) lists the tools on every run, so a server restarted with different tools is picked up; `cache_tools=True` lists once per provider instance. `tool_name_prefix`, `allowed_tools`, `approval_mode` and `parse_tool_results` work as on Agent Framework's `MCPTool`. Tool names are normalized the same way: a character outside `A-Za-z0-9_.-` becomes `-` and the separators between the prefix and the name are trimmed, so `files/read` reaches the model as `files-read` and prefix `gh_` gives `gh_files-read`. `allowed_tools` matches the server's own names. `approval_mode` is one mode for every tool of the server; the per-tool mapping `MCPTool` also takes (`always_require_approval`, `never_require_approval`) fails the workflow with `MicrosoftAgentFrameworkWorkflowError`, because `FunctionTool` would keep the dict and no tool would ask for approval. Tool results map to content the way `MCPTool` maps them (structured content as JSON text; text, images, audio, resource links and embedded resources to text or URI content; an empty result to the text `null`); a result the server marks as an error becomes an error result for the model, with the server's text in it when `include_detailed_errors` is on.
|
|
279
|
+
|
|
280
|
+
Tool names must be unique on an agent. A server tool with the name of one of the agent's own tools, or of a tool from another provider, fails the workflow with `MicrosoftAgentFrameworkWorkflowError` before the model call; give that provider a `tool_name_prefix` or an `allowed_tools` list. Tools passed to `agent.run(tools=...)` are merged after context providers run, so a collision with one of those raises Agent Framework's own `ValueError` and fails the workflow task instead; put such tools on the `Agent`.
|
|
281
|
+
|
|
282
|
+
The activity options on `TemporalMCPToolProvider` apply to its list and call Activities; `summary` defaults to the server name. Without `start_to_close_timeout` or `schedule_to_close_timeout`, `temporalio-mcp`'s one-minute default applies. The default retry policy retries without limit, so a run waits while its MCP server is down; bound it with `retry_policy` or `schedule_to_close_timeout`. A `call-tool` Activity that runs out of attempts becomes an error result for the model; a `list-tools` Activity that runs out of attempts raises from `agent.run`. A workflow cancelled during a call stops, as with `activity_as_tool`: the cancelled Activity reaches the tool as `asyncio.CancelledError`, which Agent Framework does not turn into a tool result. MCP Activities heartbeat at half the `heartbeat_timeout` while they run, and `temporalio-mcp` defaults it to 10 seconds when the provider leaves it unset. A cancel reaches a request already running on a worker only through a heartbeat, and the heartbeat timeout is how Temporal notices a lost worker before the start-to-close timeout; in Temporal Cloud each heartbeat that reaches the service is an Action, with the default at most one every 8 seconds of a running request. Pass `heartbeat_timeout=` on `TemporalMCPToolProvider` to change it, or `None` to turn heartbeats off. The worker reuses one connection per server across Activities and closes it after `mcp_connection_idle_timeout` (default 5 minutes) of idleness; `None` keeps it until shutdown and `timedelta(0)` closes it after every Activity. Do not register the same server name through `MCPPlugin` on the same worker: the Activity names clash. A server name that no worker registered has no Activity to run, so the Activity attempt fails with a retryable `NotFoundError` and the run waits until a worker with that name polls the task queue.
|
|
283
|
+
|
|
284
|
+
## Approvals (human in the loop)
|
|
285
|
+
|
|
286
|
+
Approvals are Agent Framework's own: a tool with `approval_mode="always_require"` is not executed, the run returns with the request in `response.user_input_requests`, and you answer with `request.to_function_approval_response(approved)` on the same session. In a workflow the wait is a Signal, an Update or both, and a Query shows what is pending:
|
|
287
|
+
|
|
288
|
+
```python
|
|
289
|
+
from dataclasses import dataclass
|
|
290
|
+
|
|
291
|
+
from agent_framework import Agent, tool
|
|
292
|
+
from temporalio.exceptions import ApplicationError
|
|
293
|
+
|
|
294
|
+
|
|
295
|
+
@dataclass
|
|
296
|
+
class Decision:
|
|
297
|
+
request_id: str
|
|
298
|
+
approved: bool
|
|
299
|
+
|
|
300
|
+
|
|
301
|
+
@tool(approval_mode="always_require")
|
|
302
|
+
async def delete_record(record_id: str) -> str:
|
|
303
|
+
"""Delete a record. Needs approval."""
|
|
304
|
+
return f"deleted {record_id}"
|
|
305
|
+
|
|
306
|
+
|
|
307
|
+
@workflow.defn
|
|
308
|
+
class ApprovalWorkflow:
|
|
309
|
+
def __init__(self) -> None:
|
|
310
|
+
self._pending: list[dict] = []
|
|
311
|
+
self._decisions: dict[str, bool] = {}
|
|
312
|
+
|
|
313
|
+
@workflow.signal
|
|
314
|
+
def approve(self, decision: Decision) -> None:
|
|
315
|
+
self._decisions[decision.request_id] = decision.approved
|
|
316
|
+
|
|
317
|
+
@workflow.update
|
|
318
|
+
async def decide(self, decision: Decision) -> str:
|
|
319
|
+
if decision.request_id not in {request["id"] for request in self._pending}:
|
|
320
|
+
raise ApplicationError(
|
|
321
|
+
f"unknown or stale request {decision.request_id!r}", non_retryable=True
|
|
322
|
+
)
|
|
323
|
+
self._decisions[decision.request_id] = decision.approved
|
|
324
|
+
return "recorded"
|
|
325
|
+
|
|
326
|
+
@decide.validator
|
|
327
|
+
def validate_decide(self, decision: Decision) -> None:
|
|
328
|
+
if not decision.request_id:
|
|
329
|
+
raise ValueError("request_id is required")
|
|
330
|
+
|
|
331
|
+
@workflow.query
|
|
332
|
+
def pending_requests(self) -> list[dict]:
|
|
333
|
+
return self._pending
|
|
334
|
+
|
|
335
|
+
@workflow.run
|
|
336
|
+
async def run(self, prompt: str) -> str:
|
|
337
|
+
agent = Agent(client=TemporalChatClient("gpt-4o"), tools=[delete_record])
|
|
338
|
+
session = agent.create_session()
|
|
339
|
+
response = await agent.run(prompt, session=session)
|
|
340
|
+
while response.user_input_requests:
|
|
341
|
+
requests = response.user_input_requests
|
|
342
|
+
self._pending = [request.to_dict() for request in requests]
|
|
343
|
+
await workflow.wait_condition(
|
|
344
|
+
lambda: all(request.id in self._decisions for request in requests)
|
|
345
|
+
)
|
|
346
|
+
self._pending = []
|
|
347
|
+
response = await agent.run(
|
|
348
|
+
[
|
|
349
|
+
request.to_function_approval_response(self._decisions[request.id])
|
|
350
|
+
for request in requests
|
|
351
|
+
],
|
|
352
|
+
session=session,
|
|
353
|
+
)
|
|
354
|
+
return response.text
|
|
355
|
+
```
|
|
356
|
+
|
|
357
|
+
The Update's validator checks only the argument's shape; the handler checks the id against the pending requests and raises `ApplicationError` for an unknown or stale one. Validators run before the handler, and under the time-skipping test server the workflow state a validator reads can lag behind, so a state check there fails runs that pass on a real server. Agent Framework keys approvals by the function call's id and binds the response to the request recorded in the session, so pass the same session to the second run. When a provider omits the id, the provider's client assigns one on the worker side before the response enters history, so the id in a pending request stays the same after a worker restart or a replay. A rejected approval sends the model a rejection result and the tool does not run. Agent Framework decides what happens to a request you do not answer: a response whose id matches no pending request is ignored with a log line and the request stays pending, and a run that brings a new message without answering drops the pending call from the transcript. The .NET plugin fails the run in both cases; here, check `response.user_input_requests` before the next run if a dropped request matters.
|
|
358
|
+
|
|
359
|
+
## Streaming
|
|
360
|
+
|
|
361
|
+
`agent.run(prompt, stream=True)` works as it does natively: the model Activity consumes the provider's stream, returns the updates, and the workflow iterates them and finalizes the response. To forward updates to a consumer outside the workflow while the call runs, pass `streaming_topic` and host a `WorkflowStream` on the workflow. With a topic set, every model call of that client runs as the `microsoft_agent_framework.invoke_model_streaming` Activity, with or without `stream=True`, and publishes each update in its `to_dict()` form to the topic; a batch goes out every `streaming_batch_interval` (default 100 milliseconds) or at 256 updates, whichever comes first. A run without `stream=True` gets its response assembled from the same updates:
|
|
362
|
+
|
|
363
|
+
```python
|
|
364
|
+
from agent_framework import ChatResponseUpdate
|
|
365
|
+
from temporalio.contrib.workflow_streams import WorkflowStream, WorkflowStreamClient
|
|
366
|
+
|
|
367
|
+
|
|
368
|
+
@workflow.defn
|
|
369
|
+
class StreamingWorkflow:
|
|
370
|
+
def __init__(self) -> None:
|
|
371
|
+
self._stream = WorkflowStream()
|
|
372
|
+
|
|
373
|
+
@workflow.run
|
|
374
|
+
async def run(self, prompt: str) -> str:
|
|
375
|
+
agent = Agent(client=TemporalChatClient("gpt-4o", streaming_topic="events"))
|
|
376
|
+
stream = agent.run(prompt, stream=True)
|
|
377
|
+
async for update in stream:
|
|
378
|
+
workflow.logger.debug("update %s", update.text)
|
|
379
|
+
return (await stream.get_final_response()).text
|
|
380
|
+
|
|
381
|
+
|
|
382
|
+
async def follow(client: Client, workflow_id: str) -> None:
|
|
383
|
+
async for item in WorkflowStreamClient.create(client, workflow_id).subscribe(["events"]):
|
|
384
|
+
print(ChatResponseUpdate.from_dict(item.data).text, end="", flush=True)
|
|
385
|
+
```
|
|
386
|
+
|
|
387
|
+
One streamed call records, as its Activity result, one entry per run of text deltas (the OpenAI clients' `merge_mode="append"` deltas merge too, with their `logprobs` lists concatenated and empty ones dropped; the provider's final full-text update stays its own entry), one entry per streamed function call with its argument deltas merged (the final full-arguments update stays its own entry as well), and one entry per usage or finish update, so a long answer or a large tool argument does not add one history entry per token: 200 text deltas from `OpenAIChatClient` record as 8 entries. The topic still receives every update. The workflow iterator yields the recorded entries once the Activity completes, plus whatever the framework's own loop adds (releases from 1.25 add one empty update after a tool round).
|
|
388
|
+
|
|
389
|
+
If the updates cannot all be published, the Activity fails with an `ApplicationError` of type `MicrosoftAgentFrameworkStreamError`. It is non-retryable when a retry would fail the same way: a batch over the server's payload size limit (2 MiB per payload by default) or past the run's Signal limit (each batch is one Signal; a run accepts 10,000 by default). Other publish failures, such as a server outage, are retried, and the retry calls the model again. A retried streamed call publishes from its first update again, so a subscriber sees the earlier attempt's updates followed by the whole retry; a consumer that must not repeat output keys on `response_id` (a new provider response carries a new id) or on the call ids.
|
|
390
|
+
|
|
391
|
+
## Sessions and continue-as-new
|
|
392
|
+
|
|
393
|
+
By default Temporal owns the history: unless you set `store` yourself, `TemporalChatClient` sends `store=False` to the provider, so the provider keeps no conversation of its own (the OpenAI Responses API stores one and returns its id when `store` is left unset), and when you pass a session Agent Framework keeps the transcript in the session's in-memory history and resends it on every call. Event history is the durable record and replay rebuilds the session exactly.
|
|
394
|
+
|
|
395
|
+
A long chat grows the history. Check `workflow.info().is_continue_as_new_suggested()` after each turn and carry the session as `session.to_dict()`; the next run restores it with `AgentSession.from_dict`. The dict carries the transcript, pending approval state and the provider's conversation id. Live `Agent` objects, provider connections and spans do not carry over; build them again in the new run. Your own workflow state does not carry over either: a prompt or an `end_chat` that arrived while a turn was running sits in the workflow's fields, so `ChatInput` carries those too.
|
|
396
|
+
|
|
397
|
+
```python
|
|
398
|
+
from dataclasses import dataclass, field
|
|
399
|
+
from typing import Any
|
|
400
|
+
|
|
401
|
+
from agent_framework import Agent, AgentSession
|
|
402
|
+
|
|
403
|
+
|
|
404
|
+
@dataclass
|
|
405
|
+
class ChatInput:
|
|
406
|
+
session: dict[str, Any] | None = None
|
|
407
|
+
pending: list[str] = field(default_factory=list)
|
|
408
|
+
done: bool = False
|
|
409
|
+
|
|
410
|
+
|
|
411
|
+
@workflow.defn
|
|
412
|
+
class ChatWorkflow:
|
|
413
|
+
def __init__(self) -> None:
|
|
414
|
+
self._pending: list[str] = []
|
|
415
|
+
self._done = False
|
|
416
|
+
|
|
417
|
+
@workflow.signal
|
|
418
|
+
def user_says(self, prompt: str) -> None:
|
|
419
|
+
self._pending.append(prompt)
|
|
420
|
+
|
|
421
|
+
@workflow.signal
|
|
422
|
+
def end_chat(self) -> None:
|
|
423
|
+
self._done = True
|
|
424
|
+
|
|
425
|
+
@workflow.run
|
|
426
|
+
async def run(self, input: ChatInput) -> None:
|
|
427
|
+
agent = Agent(client=TemporalChatClient("gpt-4o"), instructions="Chat.")
|
|
428
|
+
session = AgentSession.from_dict(input.session) if input.session else agent.create_session()
|
|
429
|
+
# Prompts and an end_chat that arrived while the previous run was busy.
|
|
430
|
+
self._pending = list(input.pending) + self._pending
|
|
431
|
+
self._done = self._done or input.done
|
|
432
|
+
while True:
|
|
433
|
+
await workflow.wait_condition(lambda: bool(self._pending) or self._done)
|
|
434
|
+
if not self._pending:
|
|
435
|
+
return
|
|
436
|
+
await agent.run(self._pending.pop(0), session=session)
|
|
437
|
+
if workflow.info().is_continue_as_new_suggested():
|
|
438
|
+
workflow.continue_as_new(
|
|
439
|
+
ChatInput(session=session.to_dict(), pending=self._pending, done=self._done)
|
|
440
|
+
)
|
|
441
|
+
```
|
|
442
|
+
|
|
443
|
+
To let the provider keep the conversation instead, pass `store=True` in the agent's `default_options` or a run's `options`. The returned conversation id lands in `session.service_session_id`, the next call carries it, and only the new turn crosses the boundary.
|
|
444
|
+
|
|
445
|
+
## Structured output
|
|
446
|
+
|
|
447
|
+
Pass a Pydantic class as `response_format`; it crosses to the model Activity as the strict JSON schema the OpenAI clients send natively for a class (`strict: true` under the class name, every property required, `additionalProperties: false`, `None` defaults dropped), so the provider holds the model to the schema, and the workflow parses the reply:
|
|
448
|
+
|
|
449
|
+
```python
|
|
450
|
+
from pydantic import BaseModel
|
|
451
|
+
|
|
452
|
+
|
|
453
|
+
class Person(BaseModel):
|
|
454
|
+
name: str
|
|
455
|
+
age: int
|
|
456
|
+
|
|
457
|
+
|
|
458
|
+
@workflow.defn
|
|
459
|
+
class StructuredWorkflow:
|
|
460
|
+
@workflow.run
|
|
461
|
+
async def run(self, prompt: str) -> Person:
|
|
462
|
+
agent = Agent(client=TemporalChatClient("gpt-4o"))
|
|
463
|
+
response = await agent.run(prompt, options={"response_format": Person})
|
|
464
|
+
return response.value
|
|
465
|
+
```
|
|
466
|
+
|
|
467
|
+
With the plugin on the Client, it sets [`pydantic_data_converter`](https://github.com/temporalio/sdk-python/blob/1.36.0/temporalio/contrib/pydantic.py) as the data converter unless the client already has a payload converter of its own, so Pydantic models cross the workflow boundary; a `Replayer` with the plugin gets the same converter. A Worker takes its converter from its Client, so a plugin passed to the Worker alone does not change it, which is why the quickstart registers the plugin on `Client.connect(...)`. `response.value` parses with the run's `response_format`, from an `Agent` run or from `client.get_response(...)` on the `TemporalChatClient` itself.
|
|
468
|
+
|
|
469
|
+
## Middleware and context providers
|
|
470
|
+
|
|
471
|
+
Agent, chat and function middleware run where they run natively: agent middleware in the `Agent`, chat and function middleware in `TemporalChatClient`'s layers, in the workflow. They must be deterministic, like any workflow code. Middleware that needs I/O calls `await workflow.execute_activity(...)`. Context providers run in the workflow too and may await Activities in `before_run` and `after_run`. `require_per_service_call_history_persistence` persists through the in-memory history provider inside the workflow. Compaction strategies run in the workflow; `SummarizationStrategy(client=TemporalChatClient(...))` makes its summary call an Activity.
|
|
472
|
+
|
|
473
|
+
Agent Framework's own exceptions raised in workflow code, such as `MiddlewareFailure`, fail the workflow rather than the workflow task: the plugin registers `AgentFrameworkException` and `MicrosoftAgentFrameworkWorkflowError` as workflow failure types, because retrying the task cannot change a deterministic failure.
|
|
474
|
+
|
|
475
|
+
## Limits
|
|
476
|
+
|
|
477
|
+
- `FileHistoryProvider` and `FileSessionStore` do not work in a workflow: they read and write files on a thread, which a workflow does not have, so the run fails with `MicrosoftAgentFrameworkWorkflowError` naming the call. Use the default in-memory history and carry `session.to_dict()` across continue-as-new.
|
|
478
|
+
- `MCPStdioTool`, `MCPStreamableHTTPTool` and `MCPWebsocketTool` cannot be passed in `tools=`: they hold a live connection. Use `TemporalMCPToolProvider`.
|
|
479
|
+
- `TemporalMCPToolProvider` exposes tools only: server prompts are not loaded, a result's `_meta` is not carried to the model, and there is no `tool_result_content` choice.
|
|
480
|
+
- Agent Framework creates agent spans and records tool metrics from workflow code through the global OpenTelemetry providers. With the OpenTelemetry SDK's providers set directly as the globals, every replay re-emits them; the plugin warns at worker and replayer start. Use `temporalio.contrib.opentelemetry.create_tracer_provider()` and `ReplaySafeMeterProvider`. The provider client's own chat spans run in the Activity with real timings.
|
|
481
|
+
- Synchronous tools run inline on the workflow task and block it while they run.
|
|
482
|
+
- The Workflows pillar (`WorkflowBuilder`, executors, checkpoints, `agent-framework-orchestrations`), the harness, skills, evaluations, DevUI, declarative agents, hosting, memory and vector providers and the experimental agent hooks are out of scope. Compose agents with Temporal Workflow code: signals, timers, child workflows.
|
|
483
|
+
- OpenAI background responses (`continuation_token`) and embedding clients are not routed through Activities.
|
|
484
|
+
|
|
485
|
+
## Composing with other plugins
|
|
486
|
+
|
|
487
|
+
Pass `MicrosoftAgentFrameworkPlugin` to the Client, as the quickstart does: the Worker inherits it, and only a plugin on the Client sets the data converter (a Worker takes its converter from its Client, so a plugin on the Worker alone leaves Pydantic models in Workflow inputs and outputs to the default converter). Do not pass it to both: the second copy registers the Activities twice and the Worker refuses to start. `OpenTelemetryPlugin` composes on the same Client; set the tracer provider before connecting:
|
|
488
|
+
|
|
489
|
+
```python
|
|
490
|
+
import opentelemetry.trace
|
|
491
|
+
from temporalio.contrib.opentelemetry import OpenTelemetryPlugin, create_tracer_provider
|
|
492
|
+
|
|
493
|
+
|
|
494
|
+
async def start_worker() -> None:
|
|
495
|
+
opentelemetry.trace.set_tracer_provider(create_tracer_provider())
|
|
496
|
+
client = await Client.connect(
|
|
497
|
+
"localhost:7233",
|
|
498
|
+
plugins=[OpenTelemetryPlugin(), MicrosoftAgentFrameworkPlugin(chat_clients=CHAT_CLIENTS)],
|
|
499
|
+
)
|
|
500
|
+
worker = Worker(client, task_queue="microsoft-agent-framework", workflows=[HelloWorkflow])
|
|
501
|
+
await worker.run()
|
|
502
|
+
```
|
|
503
|
+
|
|
504
|
+
The plugin passes `agent_framework`, `pydantic_core`, `annotated_types`, `msgspec`, `typing_inspection`, `opentelemetry`, `dotenv`, `mcp` and `mcp_types` through the workflow sandbox, and installs workflow-aware stand-ins for the clock, id and thread reads in Agent Framework's agent code (default agent and session ids, the loop's time budget, span durations, the thread hand-off of synchronous tools and of file-backed sessions) so they replay deterministically. Both apply to Workers and Replayers.
|
|
505
|
+
|
|
506
|
+
## Testing
|
|
507
|
+
|
|
508
|
+
`temporalio.microsoft_agent_framework.testing` ships a scripted client, so your workflow tests run without a provider:
|
|
509
|
+
|
|
510
|
+
```python
|
|
511
|
+
from temporalio.microsoft_agent_framework.testing import (
|
|
512
|
+
fake_chat_client,
|
|
513
|
+
function_call_response,
|
|
514
|
+
text_response,
|
|
515
|
+
)
|
|
516
|
+
|
|
517
|
+
plugin = MicrosoftAgentFrameworkPlugin(
|
|
518
|
+
chat_clients={
|
|
519
|
+
"gpt-4o": fake_chat_client(
|
|
520
|
+
[
|
|
521
|
+
function_call_response("fetch_user", {"user_id": "u1"}, call_id="call-1"),
|
|
522
|
+
text_response("Done."),
|
|
523
|
+
]
|
|
524
|
+
)
|
|
525
|
+
}
|
|
526
|
+
)
|
|
527
|
+
```
|
|
528
|
+
|
|
529
|
+
Each model call takes the next entry; the last one repeats. `FakeChatClient` is a full Agent Framework client, so it returns the scripted calls the way a provider would, and it records every call in `calls`.
|
|
530
|
+
|
|
531
|
+
## Develop
|
|
532
|
+
|
|
533
|
+
```bash
|
|
534
|
+
make sync # install (non-editable) into .venv
|
|
535
|
+
make lint
|
|
536
|
+
make test
|
|
537
|
+
```
|
|
538
|
+
|
|
539
|
+
`tests/test_replay.py` replays every history under `tests/histories`. A recording made before a release stays as it is: a change that needs a new one adds a file next to the old ones (`UV_NO_EDITABLE=1 uv run --locked python -m tests.record_histories --suffix <name>`), and `record_histories.py` refuses to overwrite an existing file unless `--overwrite "<reason>"` is given. `tests/histories/README.md` has the policy.
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
temporalio/microsoft_agent_framework/__init__.py,sha256=3L6kc8u5K4p1bG34DRQ0kteB-drBraT-5R2QYNJMC_s,2499
|
|
2
|
+
temporalio/microsoft_agent_framework/_activities.py,sha256=qXlz3Pie7OH2FjRJ8sl75WApLqJwtXnWqfIzy6LDtoE,15921
|
|
3
|
+
temporalio/microsoft_agent_framework/_chat_client.py,sha256=IXvT_K-Y_L3Tz-LOOPMG-l8ufxs6RnIJY8ziOCA7S6s,10099
|
|
4
|
+
temporalio/microsoft_agent_framework/_mcp.py,sha256=Srn2ssvFOa3lTpb2GrpuaCtUeJHC07A7ehyNKOlOoFU,14314
|
|
5
|
+
temporalio/microsoft_agent_framework/_plugin.py,sha256=NnkM39-AmGBhThwlbMAmkPmzpvnCy67K9CwJk3Aq_LI,13029
|
|
6
|
+
temporalio/microsoft_agent_framework/_serde.py,sha256=GqDaeXmLuqT6ZE3yrqSrPBr9yZsUCKu5jbwZjP1GNUI,23188
|
|
7
|
+
temporalio/microsoft_agent_framework/_workflow_runtime.py,sha256=66acLMRKxt1MIlWkNOcjMl53M-rGDJvV02yvXal4yH0,8787
|
|
8
|
+
temporalio/microsoft_agent_framework/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
|
|
9
|
+
temporalio/microsoft_agent_framework/testing.py,sha256=bVwledwo2LCeJ-tdT67I2g7CRkbPnlgHllCsrbZaM3Y,6607
|
|
10
|
+
temporalio/microsoft_agent_framework/workflow.py,sha256=Hqla4Ia2PNyBvK3rZrdR_UhbawH2o72KdqpiVYJaHJU,8877
|
|
11
|
+
temporalio_microsoft_agent_framework-0.0.1.dist-info/licenses/LICENSE,sha256=poHfHxdmjQGiDlKnXNmUAGkCpxqD6lmYI5e451b3lZc,1068
|
|
12
|
+
temporalio_microsoft_agent_framework-0.0.1.dist-info/WHEEL,sha256=3OmCxFA0ffBIsX4x0o8CdfSvZAOvO3mzEG8U_z5TvV4,80
|
|
13
|
+
temporalio_microsoft_agent_framework-0.0.1.dist-info/METADATA,sha256=rNkf8_jVmKYx9TblK7fuaOGxtpd5Nnjm2QzjaOF7p-Y,37697
|
|
14
|
+
temporalio_microsoft_agent_framework-0.0.1.dist-info/RECORD,,
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 temporal.io
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|