cred-semantic-kernel 1.0.0__tar.gz → 2.0.0__tar.gz

{cred_semantic_kernel-1.0.0 → cred_semantic_kernel-2.0.0}/.gitignore

@@ -25,12 +25,18 @@ HANDOFF.md
 VALIDATION.md
 MARKETING-VALIDATION.md
 FINAL-SUBMISSION-VALIDATION.md
+
+# Standards-work registers and sweep reports are built from private mail.
+# They live in the private cred-ninja/standards-private repo, never here.
+reports/
+
 .next/
 out/
 coverage/
 *.tsbuildinfo
 .turbo/
 .DS_Store
+packages/server/.test-*
 *.pem
 .env
 .env.local
@@ -48,3 +54,4 @@ venv/
 dist/
 *.dist-info/
 packages/sdk-python/.venv/
+.claude/

cred_semantic_kernel-2.0.0/LICENSE

@@ -0,0 +1,160 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and
+configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object
+code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work (an example is provided in the Appendix
+below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor for
+inclusion in the Work by the copyright owner or by an individual or Legal
+Entity authorized to submit on behalf of the copyright owner. For the purposes
+of this definition, "submitted" means any form of electronic, verbal, or
+written communication sent to the Licensor or its representatives, including
+but not limited to communication on electronic mailing lists, source code
+control systems, and issue tracking systems that are managed by, or on behalf
+of, the Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise designated in
+writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
+section) patent license to make, have made, use, offer to sell, sell, import,
+and otherwise transfer the Work, where such license applies only to those
+patent claims licensable by such Contributor that are necessarily infringed by
+their Contribution(s) alone or by combination of their Contribution(s) with the
+Work to which such Contribution(s) was submitted. If You institute patent
+litigation against any entity (including a cross-claim or counterclaim in a
+lawsuit) alleging that the Work or a Contribution incorporated within the Work
+constitutes direct or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate as of the date
+such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy
+of this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any
+part of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a
+whole, provided Your use, reproduction, and distribution of the Work otherwise
+complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may have
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied, including, without limitation, any warranties
+or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any
+character arising as a result of this License or out of the use or inability to
+use the Work (including but not limited to damages for loss of goodwill, work
+stoppage, computer failure or malfunction, or any and all other commercial
+damages or losses), even if such Contributor has been advised of the
+possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with this License. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You agree
+to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

cred_semantic_kernel-2.0.0/NOTICE

@@ -0,0 +1,8 @@
+Cred
+Copyright 2026 Cred Ninja
+
+This product includes software developed by Cred Ninja and contributors.
+
+Cred, Cred Ninja, and associated logos are trademarks or service marks of
+Cred Ninja. The Apache License 2.0 does not grant permission to use the
+Cred marks except as required for reasonable and customary attribution.

cred_semantic_kernel-2.0.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.5
+Name: cred-semantic-kernel
+Version: 2.0.0
+Summary: Cred Semantic Kernel integration — credential delegation plugin for Microsoft Semantic Kernel agents
+Project-URL: Homepage, https://cred.ninja
+Project-URL: Repository, https://github.com/cred-ninja/sdk
+Project-URL: Documentation, https://cred.ninja/docs
+Author-email: Cred <hello@cred.ninja>
+License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: ai-agents,cred,delegation,microsoft,oauth,semantic-kernel
+Requires-Python: >=3.10
+Requires-Dist: cred-auth<3.0.0,>=2.0.0
+Requires-Dist: semantic-kernel>=1.0
+Provides-Extra: dev
+Requires-Dist: hatchling; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cred-semantic-kernel
+
+Microsoft Semantic Kernel integration for Cred. OAuth2 credential delegation for AI agents.
+
+## Install
+
+```bash
+pip install cred-semantic-kernel
+```
+
+## Quick Start
+
+```python
+import os
+import semantic_kernel as sk
+from cred_semantic_kernel import CredPlugin
+from cred import AgentIdentity
+
+# The agent's own did:key identity, created once with cred.generate_agent_identity()
+# and persisted with identity.export(); load_agent_identity() stands for your own
+# secret store lookup returning that dict.
+identity = AgentIdentity.from_export(load_agent_identity())
+
+kernel = sk.Kernel()
+
+plugin = CredPlugin(
+    agent_token=os.environ["CRED_AGENT_TOKEN"],
+    base_url=os.environ["CRED_BASE_URL"],
+    user_id="user_123",
+    app_client_id="my_app_client_id",
+    token_format="handle",
+    agent_identity=identity,
+)
+
+kernel.add_plugin(plugin, plugin_name="cred")
+```
+
+## Plugin Functions
+
+The `cred` plugin exposes two kernel functions:
+
+### `delegate`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `service` | `string` | Service slug (e.g. `google`, `github`) |
+| `scopes` | `string` | Comma-separated OAuth scopes to request |
+
+`user_id` and `app_client_id` are pre-configured at construction time, not agent-controlled.
+
+By default, `delegate` returns a legacy access token for backwards compatibility. Set `token_format="handle"` to return a brokered delegation id instead, then call `use` to make allowed service API calls without exposing provider access tokens.
+
+`agent_identity` is required with `token_format="handle"`. The Cred server issues a Delegation Token (a DPoP-bound JWT) to the agent's own key and accepts it only with a DPoP proof signed by that key. The key stays in your process; it is never sent to the model or the server, and it is not a tool argument. The model only sees `delegation_id`: the token itself is kept in an in-process map (`delegation_id` to token and expiry), filled by the delegate tool and read by the use tool, so it never appears in tool output. The use tool raises a clear error if no `agent_identity` is configured or the `delegation_id` is unknown or expired (call the delegate tool again).
+
+### `use`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `delegation_id` | `string` | Delegation id returned by `delegate` |
+| `url` | `string` | Full HTTPS API URL |
+| `method` | `string` | HTTP method |
+| `body` | `string` | Optional JSON body, or empty string |
+| `extra_headers` | `string` | Optional JSON object of service-specific headers, or empty string |
+
+## Handling Consent
+
+When the user hasn't connected the service, the `delegate` function raises `ConsentRequiredError`.
+The error's `consent_url` attribute contains the URL to redirect the user.
+
+```python
+from cred import ConsentRequiredError
+
+try:
+    result = plugin.delegate(service="google", scopes="calendar.readonly")
+except ConsentRequiredError as e:
+    print(f"Redirect user to: {e.consent_url}")
+```
+
+## Brokered Server Mode
+
+Point `CRED_BASE_URL` at your self-hosted `@credninja/server` deployment and set `token_format="handle"` when you want the agent to receive delegation ids instead of provider access tokens.

cred_semantic_kernel-2.0.0/README.md

@@ -0,0 +1,81 @@
+# cred-semantic-kernel
+
+Microsoft Semantic Kernel integration for Cred. OAuth2 credential delegation for AI agents.
+
+## Install
+
+```bash
+pip install cred-semantic-kernel
+```
+
+## Quick Start
+
+```python
+import os
+import semantic_kernel as sk
+from cred_semantic_kernel import CredPlugin
+from cred import AgentIdentity
+
+# The agent's own did:key identity, created once with cred.generate_agent_identity()
+# and persisted with identity.export(); load_agent_identity() stands for your own
+# secret store lookup returning that dict.
+identity = AgentIdentity.from_export(load_agent_identity())
+
+kernel = sk.Kernel()
+
+plugin = CredPlugin(
+    agent_token=os.environ["CRED_AGENT_TOKEN"],
+    base_url=os.environ["CRED_BASE_URL"],
+    user_id="user_123",
+    app_client_id="my_app_client_id",
+    token_format="handle",
+    agent_identity=identity,
+)
+
+kernel.add_plugin(plugin, plugin_name="cred")
+```
+
+## Plugin Functions
+
+The `cred` plugin exposes two kernel functions:
+
+### `delegate`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `service` | `string` | Service slug (e.g. `google`, `github`) |
+| `scopes` | `string` | Comma-separated OAuth scopes to request |
+
+`user_id` and `app_client_id` are pre-configured at construction time, not agent-controlled.
+
+By default, `delegate` returns a legacy access token for backwards compatibility. Set `token_format="handle"` to return a brokered delegation id instead, then call `use` to make allowed service API calls without exposing provider access tokens.
+
+`agent_identity` is required with `token_format="handle"`. The Cred server issues a Delegation Token (a DPoP-bound JWT) to the agent's own key and accepts it only with a DPoP proof signed by that key. The key stays in your process; it is never sent to the model or the server, and it is not a tool argument. The model only sees `delegation_id`: the token itself is kept in an in-process map (`delegation_id` to token and expiry), filled by the delegate tool and read by the use tool, so it never appears in tool output. The use tool raises a clear error if no `agent_identity` is configured or the `delegation_id` is unknown or expired (call the delegate tool again).
+
+### `use`
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `delegation_id` | `string` | Delegation id returned by `delegate` |
+| `url` | `string` | Full HTTPS API URL |
+| `method` | `string` | HTTP method |
+| `body` | `string` | Optional JSON body, or empty string |
+| `extra_headers` | `string` | Optional JSON object of service-specific headers, or empty string |
+
+## Handling Consent
+
+When the user hasn't connected the service, the `delegate` function raises `ConsentRequiredError`.
+The error's `consent_url` attribute contains the URL to redirect the user.
+
+```python
+from cred import ConsentRequiredError
+
+try:
+    result = plugin.delegate(service="google", scopes="calendar.readonly")
+except ConsentRequiredError as e:
+    print(f"Redirect user to: {e.consent_url}")
+```
+
+## Brokered Server Mode
+
+Point `CRED_BASE_URL` at your self-hosted `@credninja/server` deployment and set `token_format="handle"` when you want the agent to receive delegation ids instead of provider access tokens.

cred_semantic_kernel-2.0.0/cred_semantic_kernel/plugin.py

@@ -0,0 +1,240 @@
+"""Cred Semantic Kernel Plugin.
+
+Provides a kernel function that delegates OAuth credentials for AI agents.
+The plugin is pre-configured with agent identity and app context at construction.
+At runtime, the agent provides ``service`` and ``scopes`` as function parameters.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from datetime import datetime
+from typing import TYPE_CHECKING, Annotated, Any, Optional
+
+from semantic_kernel.functions import kernel_function
+
+from cred import Cred
+
+if TYPE_CHECKING:
+    from cred import DpopSigningIdentity
+
+
+def _identity_kwargs(agent_identity: Any) -> dict[str, Any]:
+    """``agent_identity=`` for the SDK call, only when one is configured."""
+    return {"agent_identity": agent_identity} if agent_identity is not None else {}
+
+
+# ── Delegation token store ────────────────────────────────────────────────────
+#
+# The model only ever sees ``delegation_id``. The Delegation Token that
+# ``cred_use`` needs stays in this in-process mapping (delegation_id ->
+# (token, expiry)), populated by the delegate tool and read by the use tool.
+
+_DELEGATION_TOKENS: dict[str, tuple[str, float, str, str, Optional[str]]] = {}
+
+
+def _agent_did(agent_identity: Any) -> str:
+    return getattr(agent_identity, "did", "") or ""
+
+
+def _remember_delegation_token(
+    delegation_id: str,
+    token: str,
+    expires_at: float,
+    *,
+    base_url: str,
+    agent_did: str,
+    user_id: Optional[str] = None,
+) -> None:
+    """Store a token with the server, agent and user it was issued for."""
+    now = time.time()
+    for key in [k for k, entry in _DELEGATION_TOKENS.items() if entry[1] <= now]:
+        del _DELEGATION_TOKENS[key]
+    _DELEGATION_TOKENS[delegation_id] = (token, expires_at, base_url.rstrip("/"), agent_did, user_id)
+
+
+def _lookup_delegation_token(
+    delegation_id: str,
+    *,
+    base_url: str,
+    agent_did: str,
+    user_id: Optional[str] = None,
+) -> str:
+    """Return the token only to a tool configured for the same server, agent and user."""
+    entry = _DELEGATION_TOKENS.get(delegation_id)
+    if entry is None or entry[1] <= time.time():
+        _DELEGATION_TOKENS.pop(delegation_id, None)
+        raise ValueError("Unknown or expired delegation: call the delegate tool first")
+    _, _, entry_base_url, entry_agent_did, entry_user_id = entry
+    if (
+        entry_base_url != base_url.rstrip("/")
+        or entry_agent_did != agent_did
+        or (user_id is not None and entry_user_id != user_id)
+    ):
+        raise ValueError("This delegation was issued for a different server, agent or user")
+    return entry[0]
+
+
+def _expiry_epoch(result: Any) -> float:
+    expires_at = getattr(result, "expires_at", None)
+    if isinstance(expires_at, datetime):
+        return expires_at.timestamp()
+    expires_in = getattr(result, "expires_in", 0)
+    return time.time() + (expires_in if isinstance(expires_in, (int, float)) else 0)
+
+
+class CredPlugin:
+    """Semantic Kernel plugin for Cred credential delegation.
+
+    Pre-configured at construction with the agent token, user ID, and
+    app client ID. Exposes a single ``delegate`` kernel function.
+
+    Example::
+
+        from cred_semantic_kernel import CredPlugin
+        import semantic_kernel as sk
+
+        kernel = sk.Kernel()
+        plugin = CredPlugin(
+            agent_token=os.environ["CRED_AGENT_TOKEN"],
+            user_id="user_123",
+            app_client_id="my_app",
+            base_url=os.environ["CRED_BASE_URL"],
+            token_format="handle",
+            agent_identity=identity,  # an AgentIdentity; never shown to the model
+        )
+        kernel.add_plugin(plugin, plugin_name="cred")
+
+    Raises:
+        ConsentRequiredError: (from delegate at runtime) when the user hasn't
+            connected the requested service. The error message includes
+            ``consent_url`` so the caller can redirect the user.
+    """
+
+    def __init__(
+        self,
+        agent_token: str,
+        user_id: str,
+        app_client_id: str,
+        base_url: str,
+        token_format: str = "raw",
+        *,
+        agent_identity: Optional[DpopSigningIdentity] = None,
+    ) -> None:
+        """
+        Args:
+            agent_identity: The agent's own identity (an ``AgentIdentity`` from
+                ``cred``). Brokered handles are bound to this key: the Cred server
+                requires a DPoP proof by it to issue a handle and to use one. The
+                key stays in your process; it is never sent to the model or the server.
+        """
+        if token_format not in {"raw", "handle"}:
+            raise ValueError("token_format must be 'raw' or 'handle'")
+        self._cred = Cred(agent_token=agent_token, base_url=base_url)
+        self._base_url = base_url
+        self._user_id = user_id
+        self._app_client_id = app_client_id
+        self._token_format = token_format
+        # The agent's DPoP signing identity; never part of a kernel function's
+        # parameters or result.
+        self._agent_identity = agent_identity
+
+    @kernel_function(
+        name="delegate",
+        description=(
+            "Get delegated OAuth access for a third-party service "
+            "on behalf of the current user. "
+            "Returns JSON with either access_token or a brokered delegation_id, plus expiry, service, and scopes. "
+            "Raises an error with consent_url if the user hasn't connected the service."
+        ),
+    )
+    def delegate(
+        self,
+        service: Annotated[str, "Service slug to get a token for (e.g. 'google', 'github', 'google-calendar')."],
+        scopes: Annotated[str, "Comma-separated OAuth scopes to request (e.g. 'calendar.readonly,calendar.events'). Pass empty string to use all consented scopes."],
+    ) -> str:
+        """Delegate credentials and return JSON result."""
+        scope_list: Optional[list[str]] = None
+        if scopes:
+            scope_list = [s.strip() for s in scopes.split(",") if s.strip()]
+
+        if self._token_format == "handle":
+            result = self._cred.delegate_handle(
+                service=service,
+                user_id=self._user_id,
+                app_client_id=self._app_client_id,
+                scopes=scope_list if scope_list else None,
+                **_identity_kwargs(self._agent_identity),
+            )
+            _remember_delegation_token(
+                result.delegation_id, result.token, _expiry_epoch(result),
+                base_url=self._base_url, agent_did=_agent_did(self._agent_identity), user_id=self._user_id,
+            )
+            return json.dumps({
+                "token_type": result.token_type,
+                "expires_in": result.expires_in,
+                "service": result.service,
+                "user_id": result.user_id,
+                "scopes": result.scopes,
+                "delegation_id": result.delegation_id,
+                "note": "Pass delegation_id to use to make authenticated API calls.",
+            })
+
+        result = self._cred.delegate(
+            service=service,
+            user_id=self._user_id,
+            app_client_id=self._app_client_id,
+            scopes=scope_list if scope_list else None,
+        )
+        return json.dumps({
+            "access_token": result.access_token,
+            "token_type": result.token_type,
+            "expires_in": result.expires_in,
+            "service": result.service,
+            "scopes": result.scopes,
+            "delegation_id": result.delegation_id,
+        })
+
+    @kernel_function(
+        name="use",
+        description=(
+            "Make an authenticated API call through Cred using a brokered delegation handle. "
+            "The provider access token stays on the Cred server."
+        ),
+    )
+    def use(
+        self,
+        delegation_id: Annotated[str, "Brokered delegation handle returned by delegate."],
+        url: Annotated[str, "Full HTTPS API URL to call."],
+        method: Annotated[str, "HTTP method: GET, POST, PUT, PATCH, or DELETE."],
+        body: Annotated[str, "Optional JSON request body. Pass empty string when unused."] = "",
+        extra_headers: Annotated[str, "Optional JSON object of service-specific headers. Pass empty string when unused."] = "",
+    ) -> str:
+        """Broker an upstream API request and return JSON result."""
+        if self._agent_identity is None:
+            raise ValueError(
+                "use requires an agent_identity: the delegation token is bound to the agent's key. "
+                "Pass agent_identity= to CredPlugin.",
+            )
+        parsed_body = json.loads(body) if body else None
+        parsed_headers = json.loads(extra_headers) if extra_headers else None
+        token = _lookup_delegation_token(
+            delegation_id, base_url=self._base_url, agent_did=_agent_did(self._agent_identity), user_id=self._user_id,
+        )
+        result = self._cred.use(
+            token,
+            url=url,
+            method=method,
+            body=parsed_body,
+            extra_headers=parsed_headers,
+            agent_identity=self._agent_identity,
+        )
+        return json.dumps({
+            "status": result.status,
+            "ok": result.ok,
+            "content_type": result.content_type,
+            "body": result.body,
+            "truncated": result.truncated,
+            "truncated_at": result.truncated_at,
+        })

{cred_semantic_kernel-1.0.0 → cred_semantic_kernel-2.0.0}/pyproject.toml

@@ -4,18 +4,24 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cred-semantic-kernel"
-version = "1.0.0"
+version = "2.0.0"
 description = "Cred Semantic Kernel integration — credential delegation plugin for Microsoft Semantic Kernel agents"
 readme = "README.md"
 license = { text = "Apache-2.0" }
-requires-python = ">=3.9"
+license-files = ["LICENSE", "NOTICE"]
+requires-python = ">=3.10"
 authors = [{ name = "Cred", email = "hello@cred.ninja" }]
 keywords = ["cred", "semantic-kernel", "microsoft", "oauth", "delegation", "ai-agents"]
 dependencies = [
-    "cred-auth>=0.1.0",
+    "cred-auth>=2.0.0,<3.0.0",
     "semantic-kernel>=1.0",
 ]
 
+[project.urls]
+Homepage = "https://cred.ninja"
+Repository = "https://github.com/cred-ninja/sdk"
+Documentation = "https://cred.ninja/docs"
+
 [project.optional-dependencies]
 dev = ["pytest>=7.0", "pytest-asyncio>=0.21", "hatchling"]