Creare plug-in per Copilot Cowork

Si applica a: Microsoft 365 Copilot

Microsoft Copilot Cowork supporta l'estendibilità tramite i pacchetti di app M365, lo stesso meccanismo di distribuzione usato dalle app di Teams, dagli agenti Copilot e dai componenti aggiuntivi di Office. Puoi estendere Cowork con:

Competenze: flussi di lavoro basati su prompt che insegnano a Cowork nuove competenze di dominio, come analisi finanziarie, ricerche legali o flussi di lavoro delle risorse umane.
Connettori: server remoti che consentono a Cowork di accedere a origini dati e API esterne.

Entrambi sono raggruppati in un pacchetto di app Microsoft 365 standard e distribuiti tramite Microsoft 365 App Store.

Importante

Barriere informative Microsoft Purview (IB) non è attualmente supportato per la gestione e la condivisione di plug-in o competenze. Nei tenant in cui IB è abilitato, i caricamenti di file delle conoscenze incorporati sono bloccati a livello di tenant. In questo modo si impedisce il caricamento o la pubblicazione dei plug-in e delle funzionalità interessati.

Cosa costruirai

Un plugin di Cowork è un .zip pacchetto contenente:

my-extension.zip
├── manifest.json          # M365 Unified App Manifest (v1.28)
├── color.png              # 192×192 full-color app icon
├── outline.png            # 32×32 outline icon
└── skills/                # Agent Skills (SKILL.md files)
    ├── skill-one/
    │   ├── SKILL.md
    │   └── references/    # Optional deep-dive docs
    └── skill-two/
        └── SKILL.md

Le competenze utilizzano lo standard aperto Agent Skills, lo stesso formato supportato da Claude Code, Visual Studio Code Copilot, Gemini CLI, Cursor, JetBrains Junie, e altri 30+ strumenti di intelligenza artificiale.

Scegli il punto di partenza

Punto di partenza	Percorso	Tempo necessario per il primo pacchetto
Ho un codice Claude o un plug-in cursore esistente	Importalo	~5 minuti
Sto iniziando da zero	Creare da zero	~30 minuti

Importare un plug-in esistente

Se si dispone già di un plug-in Claude Code o Cursor con competenze e server MCP, l'interfaccia a riga di comando di Microsoft 365 Agents Toolkit (atk) lo importa direttamente. L'interfaccia della riga di comando viene eseguita in Windows, macOS e Linux.

Installare l'interfaccia della riga di comando (richiede la versione 1.1.12 o successiva):
```
npm install -g @microsoft/m365agentstoolkit-cli
```
Verificare la versione:
```
atk --version
```

Importa il tuo plugin:

atk import openplugin --path ./my-claude-plugin --output ./my-plugin-project \
  --privacy-url https://contoso.com/privacy \
  --terms-url https://contoso.com/terms

Il comando legge la .claude-plugin/plugin.json directory del plug-in (o .cursor-plugin/plugin.json), .mcp.jsone skills/ , quindi esegue lo scaffolding di un progetto Agents Toolkit contenente appPackage/manifest.json, le tue competenze e le icone generate.

È necessario includere --privacy-url e --terms-url perché i manifesti dei plug-in non hanno campi equivalenti e il manifesto di Microsoft 365 richiede entrambi.

Nota

atk import openpluginIndividua il manifesto di un plug-in in una directory con prefisso punto —.claude-plugin/plugin.json, .cursor-plugin/plugin.json, o .plugin/plugin.json—accanto a un file ..mcp.json La specifica Agent Plugins 1.0.0 pone il manifesto in una configurazione di primo livello plugin.json e MCP in mcp.json. Per importare un plug-in che segue il layout 1.0.0, sposta il suo manifesto .plugin/plugin.json e rinominalo mcp.json in .mcp.json.

Impacchetta il risultato in un file caricabile .zip:

cd my-plugin-project
atk package --manifest-file ./appPackage/manifest.json \
  --output-package-file ./appPackage/build/appPackage.zip \
  --output-folder ./appPackage/build

Nota

atk import openplugin Genera un devPreview manifesto. Gli esempi di manifesto altrove in questo articolo hanno come target lo schema v1.28. Se si pubblica tramite un canale che richiede la versione 1.28, aggiornare manifestVersion e $schema nella generata appPackage/manifest.jsone aggiungere la mcpToolDescription proprietà a ogni connettore come descritto in Descrivere gli strumenti del connettore.

Elementi che vengono importati

Artefatto del plug-in	Equivalente a M365	Note
`.claude-plugin/plugin.json`	`manifest.json`	Nome, descrizione e campi sviluppatore mappati; GUID generato automaticamente (UUID deterministico v5)
`skills/*/SKILL.md`	`agentSkills[]` Voci + `skills/` cartella	Copiato testualmente - formato identico
`.mcp.json` server	`agentConnectors[]` voci	Rilevamento automatico di URL e tipo di autenticazione
`color.png` / `outline.png`	Icone nel pacchetto	Utilizzato se presente. Segnaposto generati se mancanti

Importante

Per ogni connettore importato da .mcp.json, il generato authorization.referenceId è un segnaposto derivato dal plug-in e dal nome del server. Prima di pubblicarlo, sostituirlo con l'ID di registrazione del client OAuth effettivo. Vedere Tipi di autenticazione supportati.

Elementi che non vengono convertiti

Le funzionalità del plug-in di Claude seguenti non sono ancora supportate nel manifesto di Microsoft 365:

Funzionalità plug-in Claude	Stato
`commands/` (comandi barra)	Non ancora supportato
`agents/` (subagenti)	Non ancora supportato
`hooks/` (gestori eventi)	Non ancora supportato
`settings.json`	Non applicabile
`bin/` (eseguibili)	Non applicabile

Opzioni di importazione

Opzione	Descrizione
`--path`, `-p`	Obbligatorio. Directory del plug-in contenente `.claude-plugin/plugin.json`, `.cursor-plugin/plugin.json`, o `.plugin/plugin.json`
`--output`, `-o`	Cartella del progetto di destinazione (impostazione predefinita: `./<plugin-name>`)
`--privacy-url`	`developer.privacyUrl` per il manifesto generato
`--terms-url`	`developer.termsOfUseUrl` per il manifesto generato
`--website-url`	`developer.websiteUrl`. Torna a `homepage`, quindi `author.url`
`--app-id`	Eseguire l'override dell'UUID deterministico v5 generato per il manifesto `id`
`--default-auth-type`	`Auto` (impostazione predefinita), `None`, , `OAuthPluginVault`o `ApiKeyPluginVault`

Rilevamento automatico del tipo di autenticazione:

Origine	Tipo di autenticazione predefinito	Motivo
URL HTTPS esterni	`OAuthPluginVault`	La maggior parte delle API remote richiede l'autenticazione
`localhost` e URL non HTTPS	`None`	Server di sviluppo locali

Se il rilevamento automatico non corrisponde alla configurazione, usalo --default-auth-type per ignorarlo.

Esportare di nuovo in una directory di plugin

Per spostare un progetto Agents Toolkit in una directory di plug-in, ad esempio per mantenere sincronizzati un plug-in Claude Code e un pacchetto Cowork, utilizza:atk export openplugin

atk export openplugin --path ./my-plugin-project \
  --output ./my-claude-plugin --manifest-kind claude-plugin

Opzione	Descrizione
`--path`, `-p`	Obbligatorio. Cartella del progetto Agents Toolkit contenente `appPackage/manifest.json`
`--output`, `-o`	Directory del plug-in di destinazione (impostazione predefinita: `./<plugin-name>-openplugin`)
`--manifest-kind`	`open-plugin` (impostazione predefinita, scrive `.plugin/plugin.json`) `claude-plugin`o `cursor-plugin`

Export scrive un x-microsoft-365-agents-toolkit blocco nel file .plugin.json Tale blocco contiene il manifesto id, gli URL per sviluppatori e le impostazioni del connettore, quindi un successivo atk import openplugin round trip senza bisogno --privacy-url o --terms-url di nuovo.

Nota

Il x-microsoft-365-agents-toolkit blocco è specifico di Agents Toolkit e il tipo predefinito open-plugin scrive il manifesto in .plugin/plugin.json. Agent Plugins 1.0.0 utilizza un livello plugin.json principale e trasporta i dati specifici del client sotto una extensions chiave con uno spazio dei nomi di dominio inverso, quindi altri client ignorano questo blocco anziché agire su di esso. Quando l'obiettivo è Codice Claude o Cursore, usa --manifest-kind claude-plugin o cursor-plugin.

Legacy: script di conversione di PowerShell

Prima atk dell'importazione del plug-in supportata, la conversione usava uno script PowerShell solo Windows, che rimane disponibile come script di conversione:

.\Convert-ClaudePluginToMOS3.ps1 -PluginPath ./my-claude-plugin -OutputPath ./output

Usare atk import openplugin invece. È multipiattaforma, supporta i sorgenti Cursor e Claude Code e può esportare in una directory di plugin.

Creare un plug-in da zero

Segui questi passaggi per creare un pacchetto di plug-in da zero, partendo dalla tua prima abilità e costruendo un pacchetto completo e pubblicabile.

Passaggio 1: crea la tua prima competenza

Una competenza è una cartella contenente un SKILL.md file. Crea la seguente struttura di cartelle:

my-extension/
└── skills/
    └── contract-analysis/
        └── SKILL.md

Scrivere SKILL.md con la parte introduttiva YAML e un corpo Markdown:

---
name: contract-analysis
description: |
  Analyzes contracts for key terms, risks, and obligations.
  Use when user asks to "review this contract", "find the liability clause",
  "summarize the key terms", or "compare these two agreements".
license: MIT
metadata:
  author: Contoso Legal Tech
  version: "1.0"
---

# Contract Analysis

## What This Skill Does

Guides Cowork through systematic contract review, identifying:
- Key commercial terms (pricing, payment, renewal)
- Risk clauses (indemnification, limitation of liability, IP)
- Obligations and deadlines
- Non-standard or unusual provisions

## Workflow

1. Read the uploaded contract document
2. Extract and categorize all clauses
3. Flag risk areas with severity ratings
4. Generate a structured summary with recommendations

## Output Format

Present findings in a structured table:

| Clause | Category | Risk Level | Summary |
|--------|----------|------------|---------|
| Section 4.2-Indemnification | Risk | High | Unlimited indemnification for IP claims |
| Section 7.1-Term | Commercial | Low | 12-month auto-renewal with 30-day notice |

SKILL.md campi Introduttori

Campi obbligatori:

Campo	Vincoli	Descrizione
`name`	1-64 caratteri, kebab-case	Identificatore di competenza: deve corrispondere esattamente al nome della cartella
`description`	1-1024 caratteri	Quando usare questa abilità: includi frasi trigger

Importante

Il nome della cartella deve corrispondere al name campo in primo piano. Questa mancata corrispondenza è la causa più comune di errori di abilità.
I campi dell'elenco description dei plug-in non dovrebbero includere inviti all'azione che indirizzano gli utenti a mercati esterni per acquistare abbonamenti.

Percorso cartella	`name` campo	Valido?	Motivo
`skills/contract-analysis/SKILL.md`	`contract-analysis`	Sì	Corrispondenza tra cartella e nome
`skills/contract-analysis/SKILL.md`	`ContractAnalysis`	No	Il nome usa PascalCase invece della cartella corrispondente
`skills/my-skill/SKILL.md`	`contract-analysis`	No	La cartella è, `my-skill` ma il nome è `contract-analysis`

Regole di denominazione (kebab-case): Usare solo caratteri alfanumerici minuscoli e trattini. Non usare trattini consecutivi e non usare trattini iniziali o finali.

Esempio	Valido?	Problema
`bond-relative-value`	Sì	Minuscole con trattini
`fx-carry-trade`	Sì	Minuscole con trattini
`email`	Sì	Parola singola, senza trattini necessari
`Bond_Relative_Value`	No	Caratteri di sottolineatura e lettere maiuscole
`--my-skill--`	No	Trattini iniziali e finali
`my--skill`	No	Trattini consecutivi

Passaggio 2: Aggiungere materiale di riferimento (facoltativo)

Per competenze complesse, mantieni la sintassi principale SKILL.md e sposta i contenuti dettagliati nelle sottodirectory. Questi file aggiuntivi sono file complementari. L'abilità li carica quando necessario.

skills/
└── contract-analysis/
    ├── SKILL.md               # Core workflow (~1,500-2,000 words ideal)
    ├── references/            # Deep-dive docs loaded on demand
    │   ├── clause-taxonomy.md
    │   └── risk-scoring.md
    └── scripts/               # Executable utilities
        └── extract-clauses.py

Limiti dei file complementari

Ogni abilità può includere fino a 20 file complementari (qualsiasi file diverso da SKILL.md). Per ogni competenza, si applicano i limiti seguenti:

Limite	Valore
Numero massimo di file complementari	20
Dimensioni massime per file complementare	5 MB
Numero massimo di dimensioni totali del compagno	La dimensione massima di una cartella di lavoro che può essere aperta in Excel Services è pari a 10 MB.
Timeout download (tutti gli accompagnatori)	15 secondi

Regole del file di accompagnamento

I percorsi di file complementari devono seguire queste regole:

Usare solo percorsi relativi (non percorsi assoluti)
Nessun percorso di attraversamento (.. segmenti)
Nessuna barra rovesciata o byte Null nei nomi file
Nessun file nascosto (i nomi iniziano con .)
Nessun nome riservato di Windows (CON, PRN, AUX, COM1NUL, –COM9, –LPT9) LPT1
Il file SKILL.md stesso non viene conteggiato come file complementare
I nomi file devono usare caratteri sicuri: alfanumerici, trattini, caratteri di sottolineatura, punti, spazi e !

Per mantenere efficiente la finestra di contesto, il sistema carica le competenze in tre livelli:

Livello	Quando caricato	Dimensioni di destinazione
Frontespizio (`name` + `description`)	Sempre - all'avvio	~100 gettoni
`SKILL.md` corpo	Quando si attiva una competenza	Meno di 5.000 token (1.500-2.000 parole)
Riferimenti (`references/`)	Su richiesta dell'agente	Illimitati
Script (`scripts/`)	Eseguito, non caricato nel contesto	N/D

Fare riferimento alle directory secondarie in modo esplicito in SKILL.md modo che l'agente sappia che esistono:

## Additional Resources

- **`references/clause-taxonomy.md`**-Full taxonomy of contract clause types
- **`references/risk-scoring.md`**-Risk scoring methodology and thresholds
- **`scripts/extract-clauses.py`**-Automated clause extraction utility

Passaggio 3: Aggiungere un connettore (facoltativo)

Se l'estensione deve accedere a dati esterni, aggiungere un server MCP remoto. Questo passaggio è facoltativo. I pacchetti di sole competenze funzionano bene per i flussi di lavoro basati su prompt.

Consiglio

Se il server controlla la visibilità dello strumento per client o attribuisce il traffico in entrata, vedere Identificazione del traffico di Cowork verso il server per l'identità client presentata da Cowork.

Nota

I plug-in personalizzati non sono supportati in Cowork su dispositivi mobili.

Requisiti del connettore

Requisito	Dettagli
Trasporto	HTTP streamable (HTTPS obbligatorio, TLS 1.2+)
Protocollo	Formato messaggio JSON-RPC 2.0
Individuazione degli strumenti	Supporto `tools/list` per l'individuazione dinamica (scelta consigliata)
Esecuzione dello strumento	Supporto `tools/call` per la chiamata
Disponibilità	Tempo di attività del 99,9% SLA consigliato per le app pubblicate nello Store
Ora risposta	Meno di 30 secondi per chiamata utensile

Linee guida per la progettazione degli strumenti

Uno strumento per azione per API di piccole dimensioni (meno di 15 operazioni): search_case_law, get_ruling, cite_precedent
Ricerca + esecuzione per API di grandi dimensioni (50+ operazioni): search_actions + execute_action
Nomi descrittivi: get_bond_price no getData
Schemi di input avanzati: includi una descrizione per ogni parametro: questo è ciò che legge l'agente
Output strutturato: restituisce JSON che l'agente può formattare per l'utente
Input file: Per accettare un file dall'area di lavoro dell'utente, dichiarare il parametro con contentEncoding: base64. Per altre informazioni, vedere Accettare file dall'area di lavoro Cowork.

Descrivere gli strumenti del connettore (`mcpToolDescription`)

Ogni remoteMcpServer connettore deve includere un mcpToolDescription oggetto. La sua proprietà annidata file punta a un file JSON tool-description che impacchettate all'interno del vostro .zip e a cui fate riferimento in base a un percorso relativo dalla radice del pacchetto. Se si omette mcpToolDescription, il servizio del pacchetto rifiuta il caricamento con un errore HTTP 400:

Le proprietà richieste non sono presenti nell'oggetto: mcpToolDescription.

"remoteMcpServer": {
  "mcpServerUrl": "https://api.contoso.com/legal/mcp",
  "mcpToolDescription": {
    "file": "./tools/contoso-legal-tools.json"
  },
  "authorization": {
    "type": "OAuthPluginVault",
    "referenceId": "A1bC2dE3fH4iJ5kL6mN7oP8qR9sT0u"
  }
}

Il file di riferimento (ad esempio, tools/contoso-legal-tools.json) descrive gli strumenti esposti dal connettore e deve essere presente nel pacchetto ZIP. Includilo accanto alla manifest.json tua cartella e skills/ quando crei il pacchetto del plug-in.

Tipi di autenticazione supportati

Tipo di autenticazione	Quando si usano	Esperienza utente
`None`	API pubbliche o anonime, servizi interni	Trasparente: nessuna richiesta di autenticazione
`OAuthPluginVault`	API OAuth 2.0 (consigliate per la produzione)	L'utente completa il consenso OAuth una volta
`ApiKeyPluginVault`	Servizi basati su chiavi API	L'utente fornisce la chiave una volta

Nota

Il supporto per l'autenticazione con chiave API non è ancora disponibile in Cowork.
Se il server MCP richiede una chiave API, utilizzare OAuthPluginVault invece o Dynamic Client Registration o esporre un endpoint che accetti None.

Per OAuthPluginVault e ApiKeyPluginVault, i referenceId punti alle credenziali archiviate nell'archivio dei token di Microsoft Enterprise - i segreti non vengono mai visualizzati nel manifesto o nei file di competenza. Il referenceId valore è l'ID di registrazione del client OAuth creato quando si registra un client OAuth con Agents Toolkit.

Importante

Quando registri il client OAuth, imposta l'utilizzo per organizzazione su Qualsiasi organizzazione di Microsoft 365 per assicurarti che il plug-in funzioni tra tenant.

Autenticazione MCP

Per usare OAuth o ApiKey per l'autenticazione, consulta Configurare l'autenticazione per i plug-in MCP e API negli agenti in Microsoft 365 Copilot per i dettagli sull'installazione e la configurazione.

Dynamic Client Registration

Se il server MCP supporta Dynamic Client Registration (DCR), è possibile omettere una authentication configurazione dalla definizione del connettore e Cowork crea automaticamente un client OAuth per conto del plug-in.

È possibile omettere l'oggetto authorization , ma è comunque necessario includere mcpToolDescription. Configura l'URL del server MCP e la descrizione dello strumento e Cowork si occuperà del client OAuth:

"remoteMcpServer": {
  "mcpServerUrl": "https://api.contoso.com/legal/mcp",
  "mcpToolDescription": {
    "file": "./tools/contoso-legal-tools.json"
  }
}

Passaggio 4: Creare il manifesto

Crea manifest.json nella radice del pacchetto:

{
  "$schema": "https://developer.microsoft.com/json-schemas/teams/v1.28/MicrosoftTeams.schema.json",
  "manifestVersion": "1.28",
  "version": "1.0.0",
  "id": "YOUR-GUID-HERE",
  "developer": {
    "name": "Contoso Legal Tech",
    "websiteUrl": "https://contoso.com",
    "privacyUrl": "https://contoso.com/privacy",
    "termsOfUseUrl": "https://contoso.com/terms"
  },
  "name": {
    "short": "Contoso Legal Tools",
    "full": "Contoso Legal Tools for Copilot Cowork"
  },
  "description": {
    "short": "Contract analysis, clause extraction, and legal research",
    "full": "Comprehensive legal tools for Copilot Cowork including contract analysis, clause extraction, risk assessment, and legal research capabilities."
  },
  "icons": {
    "color": "color.png",
    "outline": "outline.png"
  },
  "accentColor": "#2B579A",
  "agentSkills": [
    { "folder": "./skills/contract-analysis" }
  ]
}

Per aggiungere un connettore, includere agentConnectors:

{
  "agentConnectors": [
    {
      "id": "contoso-legal-api",
      "displayName": "Contoso Legal Database",
      "description": "Access to case law, statutes, and regulatory databases",
      "toolSource": {
        "remoteMcpServer": {
          "mcpServerUrl": "https://api.contoso.com/legal/mcp",
          "mcpToolDescription": {
            "file": "./tools/contoso-legal-tools.json"
          },
          "authorization": {
            "type": "OAuthPluginVault",
            "referenceId": "A1bC2dE3fH4iJ5kL6mN7oP8qR9sT0u"
          }
        }
      }
    }
  ]
}

Nella configurazione del connettore, referenceId deve essere l'ID di registrazione OAuth e mcpToolDescription.file deve puntare a un file JSON di descrizione dello strumento incluso nel pacchetto ZIP.

Importante

Lo schema del manifesto v1.28 è rigoroso: si imposta additionalProperties: false alla radice, quindi qualsiasi campo non definito nello schema viene rifiutato. I campi validi nei manifesti standard dell'app Teams, ad esempio packageName—causano un errore di caricamento simile Property 'packageName' has not been defined and the schema does not allow additional properties. a Includi solo i campi visualizzati qui.

Passaggio 5: Aggiungere icone

Crea due icone PNG:

Icona	Dimensioni	Finalità
`color.png`	192×192 px	Icona dell'app a colori visualizzata nello Store e nell'elenco delle app
`outline.png`	32×32 px	Icona contorno monocolore per visualizzazioni compatte

Se non hai ancora le icone, atk import openplugin genera segnaposto a tinta unita. Sostituirli prima dell'invio al negozio.

Passaggio 6: pacchetto

Creare un file ZIP con tutto il contenuto a livello radice:

contoso-legal-tools.zip
├── manifest.json
├── color.png
├── outline.png
├── tools/
│   └── contoso-legal-tools.json   # Referenced by mcpToolDescription (connectors only)
└── skills/
    └── contract-analysis/
        ├── SKILL.md
        └── references/
            └── clause-taxonomy.md

Se il pacchetto include una agentConnectors voce, includi il file JSON tool-description a cui fa riferimento .mcpToolDescription.file I pacchetti di sole competenze non hanno bisogno di una tools/ cartella.

Windows (PowerShell):

Compress-Archive -Path manifest.json, color.png, outline.png, tools, skills -DestinationPath contoso-legal-tools.zip

macOS/Linux:

zip -r contoso-legal-tools.zip manifest.json color.png outline.png tools/ skills/

Uso di Microsoft 365 Agents Toolkit

 atk package --manifest-file ./appPackage/manifest.json \
       --output-package-file ./appPackage/build/appPackage.zip \
       --output-folder ./appPackage/build

Passaggio 7: test

Per testare l'app, caricare il pacchetto dell'app in Teams come descritto in Caricare l'app in Teams.

Per i test personali, trasferire localmente l'app usando l'interfaccia della riga di comando di Microsoft 365 Agents Toolkit:

Installa @microsoft/m365agentstoolkit-cli da npm:

npm install -g @microsoft/m365agentstoolkit-cli

Verificare l'installazione eseguendo:
```
atk --version
```
Eseguire l'autenticazione con l'account aziendale di Microsoft 365:
```
atk auth login
```
Accedere all'account aziendale e installare il pacchetto agente. Sostituire il percorso del file con il percorso del pacchetto ZIP:
```
atk install --file-path "C:/Users/myuser/myPackage.zip" --scope Personal
```
Se l'installazione riesce, viene restituito un output che include un TitleId e AppId per l'account.
Salvare questi ID per un uso successivo quando si aggiorna o si disinstalla.

Per altre informazioni, vedi l'interfaccia della riga di comando di Microsoft 365 Agents Toolkit.

Passaggio 8: Pubblicare nel tenant

Aprirel'interfaccia>di amministrazione di M365Gestire le app> Caricare app personalizzate.
Seleziona il pulsante con i puntini di sospensione (...) >Aggiungi agente.
Caricare il .zip pacchetto.
Apri iplug-inCowork>Sources & Skills>. Il plug-in viene visualizzato nella sezione Scopri .

Passaggio 9: Pubblicare al pubblico

Per i plug-in destinati alla distribuzione pubblica, inviare il plug-in all'App Store di Microsoft 365 tramite il Centro per i partner. Ulteriori informazioni in Agenti di pubblicazione per Microsoft 365 Copilot.

Test di un connettore su un server MCP locale

I connettori richiedono un HTTPS mcpServerUrl, quindi per testare un server in esecuzione sul computer è necessario esporlo tramite un URL HTTPS pubblico. I tunnel di sviluppo forniscono un inoltro che termina TLS per te.

devtunnel port create <tunnel> -p <port> --protocol http

Importante

Usa --protocol http, non https. Il --protocol flag descrive il servizio locale a cui inoltra il tunnel, non l'URL del tunnel pubblico. La maggior parte dei server MCP locali parla HTTP semplice, quindi se si imposta --protocol https mentre il server serve HTTP, ogni richiesta attraverso il tunnel restituisce un 502 errore. L'inoltro termina TLS e pubblica l'URL pubblico su HTTPS indipendentemente da questo flag.

Risoluzione dei problemi

Sintomo	Causa	Correzione
Ogni richiesta incanalata viene restituita `502` e il server locale parla HTTP	`devtunnel port create` è stato eseguito con `--protocol https`	Ricrea la porta con `--protocol http`
Le richieste tunneling vengono restituite `502` su macOS anche se il server locale è in esecuzione	Il server è associato a `0.0.0.0` (solo IPv4), ma il tunnel compone `localhost`, che si risolve prima in `::1` (IPv6)	Associare il server in `::` modo che accetti entrambe le connessioni IPv4 e IPv6
Il caricamento non riesce con `Required properties are missing from object: mcpToolDescription`	Connettore mancante `mcpToolDescription`	Aggiungere `mcpToolDescription` con un riferimento e un `file` pacchetto il file nello ZIP
Il caricamento non riesce con `Property '<field>' has not been defined and the schema does not allow additional properties`	Il manifesto include un campo non consentito dallo schema v1.28 (ad esempio, `packageName`)	Rimuovere il campo; Lo schema v1.28 usa `additionalProperties: false`

Modelli di imballaggio

Scegli il modello adatto all'estensione:

Solo competenze (nessun connettore)

Ideale per flussi di lavoro basati su prompt, analisi dei documenti e assistenza alla scrittura.

my-skills-pack.zip
├── manifest.json          # agentSkills only, no agentConnectors
├── color.png
├── outline.png
└── skills/
    ├── skill-one/SKILL.md
    └── skill-two/SKILL.md

Competenze + connettore remoto

Ideale per l'analisi dei dati, le integrazioni API e i sistemi aziendali.

my-data-skills.zip
├── manifest.json          # agentSkills + agentConnectors
├── color.png
├── outline.png
├── tools/                 # Tool-description file(s) for mcpToolDescription
│   └── my-connector.json
└── skills/
    ├── analysis-workflow/SKILL.md
    └── reporting-workflow/SKILL.md

Solo connettore (nessuna competenza personalizzata)

Usa questa opzione per le origini dati che le competenze predefinite di Cowork possono già utilizzare.

my-connector.zip
├── manifest.json          # agentConnectors only, no agentSkills
├── color.png
├── outline.png
└── tools/                 # Tool-description file(s) for mcpToolDescription
    └── my-connector.json

Plug-in di codice Claude o cursore importato

Usa questa opzione per i plug-in esistenti di altri strumenti di intelligenza artificiale destinati a Cowork.

atk import openplugin --path ./claude-plugin --output ./my-plugin-project \
  --privacy-url https://contoso.com/privacy \
  --terms-url https://contoso.com/terms

Procedure consigliate per la creazione di competenze

Segui queste linee guida per creare competenze che si attivano in modo affidabile e producono risultati coerenti.

Scrivi descrizioni efficaci

Il description campo determina quando l'agente attiva la tua competenza. Sii specifico:

# Good-specific trigger phrases, concrete scenarios
description: |
  Analyzes bond relative value using Z-spreads, ASW spreads, and butterfly analysis.
  Use when user asks to "analyze bond spreads", "compare bonds",
  "rich-cheap analysis", "relative value", or "Z-spread calculation".

# Bad-vague, no trigger phrases
description: Provides bond analytics capabilities.

Scrivi flussi di lavoro efficaci

Sii specifico nella descrizione. Includi frasi trigger: "Usa quando l'utente chiede di..." Questa descrizione è il modo in cui l'agente decide quale abilità attivare.
Struttura come flusso di lavoro. Numerare i passaggi. Ogni passaggio deve essere associato a un'azione concreta (leggere un file, chiamare uno strumento, generare output).
Definire il formato di output. Mostra l'esatta tabella, elenco o struttura del documento che gli utenti dovrebbero aspettarsi. Questa definizione migliora notevolmente la coerenza.
Strumenti di riferimento per nome. Se la tua competenza dipende dagli strumenti del connettore, assegna loro un nome esplicito: "Usa lo search_case_law strumento per..."
Mantieni il SKILL.md principale snello. Spostare il materiale di riferimento dettagliato nella references/ sottodirectory. Il corpo delle competenze dovrebbe essere il flusso di lavoro, non un'enciclopedia.

Evita gli errori comuni

Non incorporare segreti nei SKILL.md file. Usare agentConnectors con l'autenticazione per le credenziali API.
Non duplicare le competenze predefinite. Controlla l'elenco delle competenze predefinito prima di costruire.
Non rendere le competenze troppo ampie. "Fare tutto con documenti legali" è peggio di competenze specifiche per "analisi del contratto", "estrazione di clausole" e "ricerca legale".
Non codificare i percorsi dei file o i comandi di sistema. Le competenze devono essere trasferibili tra gli ambienti.
Non mettere tutto in SKILL.md. Se il corpo supera ~3.000 parole, spostare il contenuto dettagliato in references/.

Regole di convalida

Quando invii il pacchetto, la piattaforma lo convalida a più livelli. Correggere questi errori prima dell'invio per evitare il rifiuto.

Convalida a livello di manifesto

Codice	Regola	Gravità
ASKILL-M001	`folder` è obbligatorio per ogni `agentSkills` voce	Error
ASKILL-M002	`agentSkills` La matrice può contenere fino a 20 elementi	Error
ASKILL-M003	`folder` Il percorso può contenere fino a 256 caratteri	Error

Convalida a livello di pacchetto

Codice	Regola	Correzione comune	Gravità
ASKILL-P001	La cartella a cui si fa riferimento nel manifesto esiste in ZIP	Controllare la struttura ZIP	Error
ASKILL-P002	La cartella contiene un `SKILL.md` file	Aggiungi mancante `SKILL.md`	Error
ASKILL-P003	`SKILL.md` ha un frontespizio YAML valido tra `---` delimitatori	Correggere la sintassi YAML	Error
ASKILL-P004	Il campo Frontespizio include `name`	Aggiungi `name:` al frontespizio	Error
ASKILL-P005	Il campo Frontespizio include `description`	Aggiungi `description:` al frontespizio	Error
ASKILL-P006	`name` Corrisponde al nome della cartella (ultimo segmento di percorso)	Rinominare la cartella o correggere `name:`	Error
ASKILL-P007	`name` è kebab-case	Utilizzare `my-skill` not `MySkill` o `my_skill`	Error
ASKILL-P008	Nessun valore duplicato `folder` nella matrice	Rimuovere i duplicati	Error

Convalida connettore

Regola	Gravità
Ogni connettore richiede un `id` e `displayName`	Error
Tutti i valori del connettore `id` devono essere univoci all'interno del manifesto	Error
Esattamente uno di `plugin` o `remoteMcpServer`	Error
`mcpServerUrl` deve essere un URL HTTPS valido	Error
`mcpToolDescription` obbligatorio su ogni `remoteMcpServer`, con un `file` che esiste nel CAP	Error
`authorization.referenceId` obbligatorio, a meno che il tipo non sia `None`	Error
`authorization.referenceId` non deve essere presente quando il tipo è `None`	Error

Convalida file complementare

Il portale convalida i file complementari (materiali di riferimento, script e altri file insieme ) SKILL.mdal momento del caricamento e della sincronizzazione:

Regola	Gravità
Massimo 20 file complementari per competenza (escluso `SKILL.md`)	Error
Ogni file complementare deve avere dimensioni di 5 MB o inferiori	Error
Il totale dei file complementari deve essere di almeno 10 MB per competenza	Error
I percorsi dei file devono essere relativi (nessun percorso assoluto)	Error
Nessun segmento di attraversamento del percorso (`..`)	Error
Nessuna barra rovesciata o byte Null nei nomi file	Error
Nessun file nascosto (i nomi iniziano con `.`)	Error
Nessun nome riservato di Windows (`CON`, `PRN`, `AUX`, `COM1NUL`, –`COM9`, –`LPT9`) `LPT1`	Error
I nomi file devono usare solo caratteri sicuri (alfanumerici, trattini, caratteri di sottolineatura, punti, spazi, `!`)	Error

Compatibilità multipiattaforma

Le competenze usano lo standard aperto Competenze agente. Gli stessi SKILL.md file funzionano su più strumenti di intelligenza artificiale:

Piattaforma	Compatibilità
Claude Code	Intero stesso `SKILL.md` formato
Progetti di Claude.ai	Le competenze complete possono essere caricate come file di progetto
VS Code / GitHub Copilot	Full-Agent Competenze supportate in modalità agente
Gemini CLI	Full-Agent Competenze supportate
JetBrains Junie	Full-Agent Competenze supportate
OpenAI Codex	Full-Agent Competenze supportate
Cursore	Full-Agent Competenze supportate

Se stai sviluppando competenze sia per Claude Code che per Cowork, inizia con la struttura del plug-in Claude Code: è il superset:

my-plugin/
├── .claude-plugin/
│   └── plugin.json        # Claude plugin manifest
├── skills/
│   ├── skill-one/
│   │   ├── SKILL.md       # Works in both Claude Code AND M365
│   │   └── references/
│   └── skill-two/
│       └── SKILL.md
└── .mcp.json              # MCP server config (optional)

Quindi, importarlo in un progetto M365 quando si è pronti per la pubblicazione nell'App Store di Microsoft 365:

atk import openplugin --path ./my-plugin --output ./my-plugin-project \
  --privacy-url https://contoso.com/privacy \
  --terms-url https://contoso.com/terms

Gestione annotazioni e conferme MCP

Copilot Cowork legge l'oggetto MCP annotations standard sugli strumenti restituiti dal server e tools/listlo usa per decidere se una chiamata allo strumento richiede la conferma dell'utente e quale etichetta mostrare nel prompt.

Campi disponibili

Campo	Tipo	Effetto
`readOnlyHint`	bool	`false`: è necessaria una conferma prima dell'esecuzione dello strumento.
`destructiveHint`	bool	`true`: è necessaria una conferma prima dell'esecuzione dello strumento.
`title`	stringa	Etichetta leggibile nella finestra di dialogo di conferma. Torna al nome dello strumento quando è assente.

Regole di conferma

È richiesta la conferma se readOnlyHint == false o destructiveHint == true.

Tutti gli strumenti devono avere annotazioni di sicurezza specificate. Gli strumenti senza annotazioni vengono considerati distruttivi e richiedono conferma. Per altre informazioni, vedi la guida di riferimento allo schema MCP.

Esempi di MCP

Un'azione distruttiva con un'etichetta amichevole:

{
  "name": "send_email",
  "description": "Send an email message.",
  "annotations": {
    "title": "Send Email",
    "destructiveHint": true
  },
  "inputSchema": { ... }
}

Una lettura sicura che esegue automaticamente:

{
  "name": "search_docs",
  "annotations": {
    "title": "Search Documents",
    "readOnlyHint": true
  }
}

Cosa è disponibile ora

Gli strumenti Microsoft (Graph, Dataverse e altri) sono controllati dai criteri integrati di Cowork indipendentemente dalle annotazioni.
Per i server non Microsoft MCP, la conferma basata su annotazioni viene distribuita progressivamente. L'impostazione dei suggerimenti ora è compatibile con le versioni successive e la richiesta di conferma viene visualizzata man mano che l'implementazione si espande senza che sia necessaria alcuna modifica allo sviluppatore.

Accettare file dall'area di lavoro Cowork

Uno strumento connettore può prendere come input un file dalla sessione Cowork dell'utente, ovvero un documento allegato dall'utente, un allegato e-mail salvato da Cowork o un file prodotto da un passaggio precedente. Dichiara il parametro con la parola contentEncoding: base64 chiave standard JSON Schema e Cowork gestisce il resto. Non è necessaria alcuna estensione dello schema specifica di Microsoft e la superficie API del server non cambia.

Cowork risolve il file dell'area di lavoro e lo codifica in base 64 prima di chiamare il server, quindi i byte di file non entrano mai nel contesto dell'agente. L'agente vede ed genera solo i percorsi dei file dell'area di lavoro.

Nota

Non indicare all'agente di codificare in base 64 un file e incollare il BLOB in una chiamata allo strumento. In questo modo viene caricato l'intero file nel contesto del modello e dipende dal modello che riproduce esattamente il BLOB. Sembra funzionare su piccoli file di prova e fallisce su quelli reali.

Dichiarare un parametro di file

Una proprietà stringa con contentEncoding: base64 è riconosciuta come input di file:

{
  "name": "analyze_contract",
  "description": "Extract key terms from a contract document.",
  "annotations": {
    "title": "Analyze Contract",
    "readOnlyHint": true
  },
  "inputSchema": {
    "type": "object",
    "properties": {
      "document": {
        "type": "string",
        "contentEncoding": "base64",
        "description": "The contract file to analyze."
      },
      "jurisdiction": {
        "type": "string",
        "description": "Two-letter country code governing the contract."
      }
    },
    "required": ["document"]
  }
}

Viene riconosciuta anche una matrice di tali stringhe, per gli strumenti che accettano diversi file:

"attachments": {
  "type": "array",
  "items": { "type": "string", "contentEncoding": "base64" },
  "description": "Receipt images to attach to the expense line."
}

Cosa vede l'agente

Per i parametri di file dichiarati al livello superiore di , Cowork li sostituisce nello schema rivolto al modello con una singola direct_attachment_file_paths matrice, lo stesso parametro utilizzato dagli strumenti integrati di inputSchema.propertiesCowork, quindi l'agente sa già come popolarlo. Lo schema precedente viene presentato all'agente come:

{
  "type": "object",
  "properties": {
    "direct_attachment_file_paths": {
      "type": "array",
      "items": { "type": "string" },
      "description": "Workspace file paths to attach."
    },
    "jurisdiction": { "type": "string" }
  }
}

Se lo strumento dichiara più parametri di file di primo livello, tutti vengono compressi in quella singola direct_attachment_file_paths matrice. Al momento della chiamata, Cowork apre a ventaglio i file risolti nei nomi dei parametri originali nell'ordine della dichiarazione.

Parametri di file annidati

È supportato anche un parametro di file annidato all'interno di un oggetto o di un array di oggetti e viene gestito in modo diverso: invece di essere compresso, viene riscritto in posizione in una stringa di percorso nella sua posizione. In questo modo viene mantenuta l'associazione tra un file e i relativi campi di pari livello, ad esempio una ricevuta per ogni riga di spesa:

"line_items": {
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "amount": { "type": "number" },
      "receipt": { "type": "string", "contentEncoding": "base64" }
    }
  }
}

L'agente viene line_items[].receipt popolato con un percorso dell'area di lavoro e Cowork scambia ogni percorso con il contenuto base64 sul posto prima di inoltrare la chiamata.

L'annidamento viene attraversato fino a una profondità di quattro livelli al di sotto della sommità di inputSchema. $refI puntatori non vengono seguiti: definire i parametri del file in linea anziché dietro un file .$ref

Cosa riceve il server

Il server riceve un normale tools/call con i nomi dei parametri originali popolati con contenuto con codifica base64:

{
  "method": "tools/call",
  "params": {
    "name": "analyze_contract",
    "arguments": {
      "document": "JVBERi0xLjQKJcfsj6IKNSAwIG9iago8PC9MZW5...",
      "jurisdiction": "US"
    }
  }
}

Il server non deve sapere che l'agente ha usato un'interfaccia basata su percorso e gli strumenti che non dichiarano contentEncoding: base64 parametri non sono interessati.

Limiti

Limite	Valore
Files per chiamata di strumento	8
Dimensioni per file	150 MiB
Dimensione totale per chiamata utensile	150 MiB
Parametri del file di matrice per strumento	1 (combinalo con un numero qualsiasi di parametri di file scalari)
Profondità di annidamento massima	4 livelli sotto la parte superiore di `inputSchema`

Una chiamata che supera il numero di file o un limite di dimensione ha esito negativo con un errore dello strumento e non raggiunge mai il server. Ridimensiona la tua API e i suoi timeout tenendo presente il limite di 150 MiB: base64 gonfia il payload di circa un terzo rispetto alle dimensioni del file grezzo e il contenuto codificato viene inviato nel corpo della richiesta JSON-RPC.

Consigli

Descrivere il parametro per un lettore umano. L'agente usa la descrizione per decidere quale file appartiene a quale parametro. Ad esempio, "The signed contract PDF to analyze" funziona meglio di "file".
Indicare i formati accettati nella descrizione del parametro. Cowork passa attraverso qualsiasi cosa l'utente collega. Convalida il tipo di contenuto dalla tua parte e restituisci un chiaro errore di strumento se non è utilizzabile.
Impostare le annotazioni. Uno strumento che riceve un file e agisce su di esso in genere non è di sola lettura, quindi richiede una conferma. Vedere Gestione delle annotazioni e delle conferme MCP.
Mantenere i parametri del file inline. Un parametro dietro a , $refo annidato più in profondità di quattro livelli, non viene riscritto. Il server riceverà una stringa di percorso in cui si aspetta il contenuto.
Dichiara al massimo un parametro del file di matrice per strumento. Con due o più, Cowork non è in grado di stabilire quale file appartiene a quale array e la chiamata ha esito negativo con un errore dello strumento. Utilizzare una matrice, o più parametri scalari, o una combinazione di scalari e una singola matrice.
Aspettatevi un conteggio esatto sugli strumenti solo scalari. Se lo strumento dichiara solo parametri di file scalari, il numero di file passati dall'agente deve corrispondere al numero dichiarato. Contrassegna chiaramente i parametri facoltativi del file nelle loro descrizioni, in modo che l'agente non fornisca troppo o troppo poco.

Nota

Questo meccanismo precede il lavoro di input di file del protocollo di contesto del modello, che viene standardizzato dal gruppo di lavoro sui caricamenti di file MCP. Cowork potrebbe aggiungere il supporto per la forma standardizzata di input di file dichiarativi una volta arrivato. Il contentEncoding: base64 contratto qui descritto continua a funzionare.

Identifica il traffico di Cowork verso il tuo server

Se il server MCP controlla la visibilità dello strumento per client o si desidera attribuire il traffico ricevuto, è possibile riconoscere le richieste provenienti da Cowork. Cowork presenta un'identità software stabile su due canali:

Canale	Dove appare	Valore
`User-Agent` intestazione della richiesta	Ogni richiesta in uscita che Cowork invia al tuo server	`copilot-cowork/1.0`
`clientInfo`nell'handshake MCP `initialize`	Solo `initialize` la richiesta	`{ "name": "copilot-cowork", "version": "<version>" }`

Corrispondenza sul `copilot-cowork` prefisso

Abbinare il copilot-coworkprefisso, senza distinzione tra maiuscole e minuscole, su entrambi i canali. Non corrispondono alla stringa esatta copilot-cowork/1.0 o a uno specifico clientInfo.versionfile . La versione tiene traccia del contratto di identità client ed è prevista una modifica. Una corrispondenza di prefisso mantiene il tuo cancello funzionante attraverso i bump di versione.

# Correct: case-insensitive prefix match
copilot-cowork

# Incorrect: exact match breaks when the version changes
copilot-cowork/1.0

Scegli il canale giusto per il tuo gate

I due canali hanno ambiti diversi, quindi è fondamentale quello che corrisponde al modo in cui il server applica il suo gate:

L'intestazione User-Agent è presente in ogni richiesta, inclusi tools/list e tools/call. Se si esegue il gate o l'attributo per richiesta, la chiave su questa intestazione.
clientInfo viene inviato solo con la stretta di initialize mano. Se si esegue il gate per sessione al momento della connessione, è possibile leggerlo lì, ma non viene ripetuto nelle richieste successive.

Cosa include e cosa non include l'identità

L'identità indica solo il software . È lo stesso per ogni utente e connessione di Cowork e non trasmette mai l'identità dell'utente. L'identità dell'utente rimane nel flusso di autorizzazione definito dalla configurazione dell'autenticazione del connettore.

L'identità include	L'identità non include
Un nome software stabile (`copilot-cowork`) e una versione del contratto	Qualsiasi identificatore di tenant, utente, sessione o conversazione
Lo stesso valore su ogni richiesta e ogni connessione	Qualificatore per connettore

Poiché non esiste alcun qualificatore per connettore, al momento non è possibile usare questa identità per indicare quale connettore ha effettuato una chiamata o per separare un plug-in Microsoft pubblicato da un server trasferito localmente che punta allo stesso URL. Se è necessaria tale distinzione, applicarla tramite la configurazione dell'autorizzazione del connettore anziché l'identità client.

Domande comuni

È possibile usare le competenze del pacchetto M365 in Claude Code?

Sì. Le cartelle delle abilità contengono le competenze standard degli agenti. Copiali in .claude/skills/ qualsiasi progetto Claude Code o eseguili atk export openplugin per riconvertire l'intero progetto in un plug-in Claude Code.

È necessario un connettore remoto?

No. I pacchetti di sole competenze funzionano bene per i flussi di lavoro basati su prompt. I connettori sono necessari solo quando la tua competenza richiede dati in tempo reale da un sistema esterno.

In che modo le competenze plug-in sono diverse dalle competenze integrate?

Le competenze dei plug-in vengono visualizzate con sorgente "package" nell'API. Non possono sostituire le competenze predefinite con lo stesso nome. I pacchetti distribuiti dall'Amministrazione mostrano isAdminDeployed: true.

Gli amministratori IT possono controllare quali plug-in sono disponibili?

Sì. Si applicano i controlli di amministrazione di M365 Standard: elenchi di indirizzi consentiti/bloccati a livello di tenant, distribuzioni gestite dall'amministratore e criteri di conformità.

Cosa succede se un plugin viene revocato?

Nel ciclo di sincronizzazione successivo, le competenze e i connettori del pacchetto vengono rimossi dalla sessione dell'utente. Le conversazioni attive non vengono interrotte, ma le nuove sessioni non dispongono delle funzionalità del pacchetto.

Qual è il numero massimo di competenze per pacchetto?

Venti (20) abilità (per ASKILL-M002). Per i connettori, il limite è 10 per pacchetto.

Le competenze possono fare riferimento agli strumenti connettore dello stesso pacchetto?

Sì, e dovrebbero. Assegna un nome esplicito agli strumenti nel flusso SKILL.md di lavoro (ad esempio, "Usa lo search_case_law strumento per..."). L'agente li connette al momento del runtime.

Gli strumenti del mio plugin possono accettare file dall'area di lavoro di Cowork?

Sì. Dichiara il parametro dello strumento con contentEncoding: base64, e Cowork risolve il file dell'area di lavoro dell'utente nel contenuto base64 prima di chiamare il server. Il modello passa i percorsi dei file, non il contenuto dei file, quindi i file di grandi dimensioni non utilizzano il contesto del modello. Per i dettagli e i limiti della dichiarazione, vedere Accettare file dall'area di lavoro Cowork.

Ricerca per categorie generare un GUID deterministico per il pacchetto?

atk import openplugin utilizza UUID v5 (basato su SHA-1) dal nome del plug-in. Eseguire l'importazione due volte produce lo stesso GUID. Per impostare il proprio, passa --app-id. Per l'imballaggio manuale, utilizzare un generatore GUID qualsiasi. Assicurati di mantenerlo stabile in tutte le versioni.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-08-28

Creare plug-in per Copilot Cowork

Cosa costruirai

Scegli il punto di partenza

Importare un plug-in esistente

Elementi che vengono importati

Elementi che non vengono convertiti

Opzioni di importazione

Esportare di nuovo in una directory di plugin

Legacy: script di conversione di PowerShell

Creare un plug-in da zero

Passaggio 1: crea la tua prima competenza

SKILL.md campi Introduttori

Passaggio 2: Aggiungere materiale di riferimento (facoltativo)

Limiti dei file complementari

Regole del file di accompagnamento

Passaggio 3: Aggiungere un connettore (facoltativo)

Requisiti del connettore

Linee guida per la progettazione degli strumenti

Descrivere gli strumenti del connettore (mcpToolDescription)

Tipi di autenticazione supportati

Autenticazione MCP

Dynamic Client Registration

Passaggio 4: Creare il manifesto

Passaggio 5: Aggiungere icone

Passaggio 6: pacchetto

Passaggio 7: test

Passaggio 8: Pubblicare nel tenant

Passaggio 9: Pubblicare al pubblico

Test di un connettore su un server MCP locale

Risoluzione dei problemi

Modelli di imballaggio

Solo competenze (nessun connettore)

Competenze + connettore remoto

Solo connettore (nessuna competenza personalizzata)

Plug-in di codice Claude o cursore importato

Procedure consigliate per la creazione di competenze

Scrivi descrizioni efficaci

Scrivi flussi di lavoro efficaci

Evita gli errori comuni

Regole di convalida

Convalida a livello di manifesto

Convalida a livello di pacchetto

Convalida connettore

Convalida file complementare

Compatibilità multipiattaforma

Gestione annotazioni e conferme MCP

Campi disponibili

Regole di conferma

Esempi di MCP

Cosa è disponibile ora

Accettare file dall'area di lavoro Cowork

Dichiarare un parametro di file

Cosa vede l'agente

Parametri di file annidati

Cosa riceve il server

Limiti

Consigli

Identifica il traffico di Cowork verso il tuo server

Corrispondenza sul copilot-cowork prefisso

Scegli il canale giusto per il tuo gate

Cosa include e cosa non include l'identità

Domande comuni

Contenuto correlato

Commenti e suggerimenti

Risorse aggiuntive

Descrivere gli strumenti del connettore (`mcpToolDescription`)

Corrispondenza sul `copilot-cowork` prefisso